@fc3/mmcadi 0.1.0

package/src/lib/grammar/noun-inflector.ts

@@ -0,0 +1,104 @@
+const SINGULAR_TO_PLURAL_MAP: Record<string, string> = {
+	loot: 'loot'
+};
+
+class NounInflector {
+	public singularize(plural_form: string): string {
+		for (const singular_key in SINGULAR_TO_PLURAL_MAP) {
+			if (SINGULAR_TO_PLURAL_MAP[singular_key] === plural_form) {
+				return singular_key;
+			}
+		}
+
+		if (plural_form.slice(-3) === 'ies') {
+			return plural_form.slice(0, -3) + 'y';
+		}
+
+		if (plural_form.slice(-1) === 'i') {
+			return plural_form.slice(0, -1) + 'us';
+		}
+
+		if (plural_form.slice(-1) === 's') {
+			return plural_form.slice(0, -1);
+		}
+
+		return plural_form;
+	}
+
+	public pluralize(singular_form: string): string {
+		if (SINGULAR_TO_PLURAL_MAP[singular_form] !== undefined) {
+			return SINGULAR_TO_PLURAL_MAP[singular_form];
+		}
+
+		if (singular_form.slice(-1) === 'y') {
+			if (!this.isVowel(singular_form.slice(-2, -1))) {
+				return singular_form.slice(0, -1) + 'ies';
+			}
+		}
+
+		if (singular_form.slice(-2) === 'ch') {
+			return singular_form + 'es';
+		}
+
+		if (singular_form.slice(-2) === 'us') {
+			return singular_form.slice(0, -2) + 'i';
+		}
+
+		if (singular_form.slice(-2) === 'ss') {
+			return singular_form + 'es';
+		}
+
+		if (singular_form === 'life') {
+			return 'lives';
+		}
+
+		return singular_form + 's';
+	}
+
+	/**
+	 * Takes a number, and a singular suffix noun, and returns the correctly
+	 * formatted result for the given number.
+	 *
+	 * Example:
+	 *
+	 *    singularizeOrPluralize(1, 'account')   =>   '1 account'
+	 *    singularizeOrPluralize(6, 'account')   =>   '6 accounts'
+	 */
+	public singularizeOrPluralize(
+		amount: string | number,
+		suffix: string
+	): string {
+		if (typeof amount === 'string') {
+			amount = parseFloat(amount);
+		}
+
+		if (amount === 1) {
+			return `${amount} ${suffix}`;
+		}
+
+		const plural_suffix = this.pluralize(suffix);
+
+		return `${amount} ${plural_suffix}`;
+	}
+
+	public prependArticle(suffix: string): string {
+		const first_letter = suffix[0];
+		const is_vowel = this.isVowel(first_letter);
+
+		let article: string;
+
+		if (is_vowel) {
+			article = 'an';
+		} else {
+			article = 'a';
+		}
+
+		return `${article} ${suffix}`;
+	}
+
+	private isVowel(letter: string): boolean {
+		return /[aeiou]/.test(letter.toLowerCase());
+	}
+}
+
+export default NounInflector;

package/src/lib/grammar/utility/get-words-from-identifier.ts

@@ -0,0 +1,9 @@
+function getWordsFromIdentifier(identifier: string): string[] {
+	const delimited_identifier = identifier.replace(/[a-z][A-Z]/g, (match) => {
+		return match[0] + '_' + match[1];
+	});
+
+	return delimited_identifier.split('_');
+}
+
+export default getWordsFromIdentifier;

package/src/lib/grammar/verb-inflector.ts

@@ -0,0 +1,344 @@
+import {capitalize} from 'lib/string';
+import NounInflector from 'lib/grammar/noun-inflector';
+
+class VerbInflector {
+	private value: string;
+	private verb: string;
+	private suffix: string;
+	private uppercase: boolean;
+
+	public constructor(value: string) {
+		this.value = value;
+
+		const index = value.indexOf(' ');
+
+		if (index !== -1) {
+			this.suffix = value.slice(index);
+
+			value = value.slice(0, index);
+		} else {
+			this.suffix = '';
+		}
+
+		this.uppercase = value !== value.toLowerCase();
+		this.verb = value.toLowerCase();
+	}
+
+	public toPresentParticiple(): string {
+		if (this.verb === 'group') {
+			return this.finalize('grouping');
+		}
+
+		if (this.verb === 'be') {
+			return this.finalize('being');
+		}
+
+		// stop -> stopping
+		if (/[aeiou]p$/.test(this.verb)) {
+			return this.finalize(this.verb + 'ping');
+		}
+
+		// log -> logging
+		if (/[aeiou]g$/.test(this.verb)) {
+			return this.finalize(this.verb + 'ging');
+		}
+
+		// free -> freeing
+		if (/ee$/.test(this.verb)) {
+			return this.finalize(this.verb + 'ing');
+		}
+
+		// wave -> waving
+		if (/e$/.test(this.verb)) {
+			return this.finalize(this.verb.slice(0, -1) + 'ing');
+		}
+
+		// run -> running
+		if (/[aeiou]n$/.test(this.verb)) {
+			return this.finalize(this.verb + 'ning');
+		}
+
+		// pet -> petting
+		if (/[aeiou]t$/.test(this.verb)) {
+			return this.finalize(this.verb + 'ting');
+		}
+
+		return this.finalize(this.verb + 'ing');
+	}
+
+	public toPastParticiple(): string {
+		switch (this.verb) {
+			case 'choose':
+				return this.finalize('chosen');
+
+			default:
+				return this.toPastTense();
+		}
+	}
+
+	public toInfinitive(): string {
+		return this.finalize(`to ${this.verb}`);
+	}
+
+	public toAdjective(): string {
+		if (this.value.startsWith('be ')) {
+			return this.value.slice(3);
+		} else {
+			return this.finalize(this.verb + 'y');
+		}
+	}
+
+	public toPresentTense(): string {
+		switch (this.verb) {
+			case 'be':
+				return this.finalize('is');
+			default:
+				return this.finalize(this.verb);
+		}
+	}
+
+	public toImperfectTense(): string {
+		const participle = this.toPresentParticiple();
+
+		return this.finalize(`was ${participle}`);
+	}
+
+	public toPastTense(): string {
+		switch (this.verb) {
+			case 'find':
+				return this.finalize('found');
+			case 'get':
+				return this.finalize('got');
+			case 'run':
+				return this.finalize('ran');
+			case 'read':
+				return this.finalize('read');
+			case 'write':
+				return this.finalize('wrote');
+			case 'choose':
+				return this.finalize('chose');
+			case 'build':
+				return this.finalize('built');
+		}
+
+		// stop -> stopped
+		if (/[aeiou]p$/.test(this.verb)) {
+			return this.finalize(this.verb + 'ped');
+		}
+
+		// log -> logged
+		if (/[aeiou]g$/.test(this.verb)) {
+			return this.finalize(this.verb + 'ged');
+		}
+
+		if (this.verb === 'be') {
+			return this.finalize('was');
+		}
+
+		if (this.verb === 'draw') {
+			return this.finalize('drew');
+		}
+
+		// wave -> waved
+		if (/e$/.test(this.verb)) {
+			return this.finalize(this.verb + 'd');
+		}
+
+		// destroy -> destroyed
+		if (/[aeiou]y$/.test(this.verb)) {
+			return this.finalize(this.verb + 'ed');
+		}
+
+		// party -> partied
+		if (/y$/.test(this.verb)) {
+			return this.finalize(this.verb.slice(0, -1) + 'ied');
+		}
+
+		return this.finalize(this.verb + 'ed');
+	}
+
+	public toFutureTense(): string {
+		return this.finalize(`will ${this.verb}`);
+	}
+
+	public toSingularNoun(): string {
+		switch (this.verb) {
+			case 'cut':
+				return this.finalize('cut');
+
+			case 'die':
+				return this.finalize('death');
+
+			case 'live':
+				return this.finalize('life');
+
+			case 'change':
+				return this.finalize('change');
+
+			case 'make water':
+				return this.finalize('water');
+
+			case 'do':
+				return this.finalize('action');
+
+			case 'protect':
+				return this.finalize('protection');
+
+			case 'affirm':
+				return this.finalize('affirmation');
+
+			case 'choose':
+				return this.finalize('choice');
+
+			case 'collide':
+				return this.finalize('collision');
+
+			case 'encase':
+				return this.finalize('casing');
+
+			case 'darken':
+				return this.finalize('shadow');
+
+			case 'damage':
+				return this.finalize('damage');
+
+			case 'define':
+				return this.finalize('definition');
+
+			case 'describe':
+				return this.finalize('description');
+
+			case 'hear':
+				return this.finalize('sound');
+
+			case 'measure':
+				return this.finalize('measurement');
+
+			case 'rate':
+				return this.finalize('rating');
+
+			case 'move':
+				return this.finalize('movement');
+
+			case 'regard':
+				return this.finalize('regard');
+
+			case 'survey':
+				return this.finalize('area');
+
+			case 'interact':
+				return this.finalize('interaction');
+
+			case 'name':
+				return this.finalize('name');
+
+			case 'speak':
+				return this.finalize('speech');
+
+			case 'count':
+				return this.finalize('number');
+
+			case 'reside':
+				return this.finalize('residence');
+
+			case 'know':
+				return this.finalize('knowledge');
+
+			case 'divide':
+				return this.finalize('division');
+
+			case 'void':
+				return this.finalize('void');
+
+			case 'make':
+				switch (this.value) {
+					case 'make music':
+						return 'music';
+					case 'make noise':
+						return 'noise';
+					default:
+						return this.suffix.slice(1);
+				}
+
+			case 'breathe':
+				return this.finalize('breath');
+
+			case 'have':
+				return this.finalize('belonging');
+
+			case 'bear':
+				if (this.suffix === ' fruit') {
+					return 'fruit';
+				}
+
+			case 'dream':
+				return 'dream';
+
+			case 'test':
+				return 'test';
+
+			case 'prepare':
+				return 'preparation';
+
+			case 'ascend':
+				return 'ascension';
+
+			case 'sleep':
+				return 'sleep';
+
+			default:
+				if (this.verb.slice(-2) === 'te') {
+					return this.finalize(this.verb.slice(0, -2) + 'tion');
+				}
+
+				return this.finalize(this.toPresentParticiple());
+		}
+	}
+
+	public toPluralNoun(): string {
+		const inflector = new NounInflector();
+		const singular = this.toSingularNoun();
+
+		return this.finalize(inflector.pluralize(singular));
+	}
+
+	public toSingularActor(): string {
+		switch (this.verb) {
+			case 'be':
+				return this.finalize('being');
+		}
+
+		if (this.verb.endsWith('ate')) {
+			return this.finalize(`${this.verb.slice(0, -1)}or`);
+		}
+
+		if (this.verb.endsWith('e')) {
+			return this.finalize(`${this.verb}r`);
+		}
+
+		if (this.verb.endsWith('ct')) {
+			return this.finalize(`${this.verb}or`);
+		}
+
+		return this.finalize(`${this.verb}er`);
+	}
+
+	public toPluralActor(): string {
+		const singular_actor = this.toSingularActor();
+		const inflector = new NounInflector();
+
+		return this.finalize(inflector.pluralize(singular_actor));
+	}
+
+	private finalize(value: string): string {
+		value += this.suffix;
+
+		if (this.uppercase) {
+			return capitalize(value);
+		} else {
+			return value.toLowerCase();
+		}
+	}
+}
+
+export default VerbInflector;

package/src/lib/http/buffer-stream.ts

@@ -0,0 +1,76 @@
+import {Duplex} from 'stream';
+
+interface Callback {
+	(): void;
+}
+
+class BufferStream extends Duplex {
+	private is_closed: boolean;
+	private buffer: Buffer | undefined;
+
+	public constructor() {
+		super();
+
+		this.is_closed = false;
+		this.buffer = Buffer.alloc(0);
+
+		this.on('finish', this.handleFinished.bind(this));
+	}
+
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public _read(): void {
+		if (this.isBuffering()) {
+			this.emptyBuffer();
+		}
+
+		if (this.isClosed()) {
+			this.pushClosed();
+		}
+	}
+
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public _write(chunk: Buffer, _encoding: string, callback: Callback): void {
+		if (this.isBuffering()) {
+			this.addToBuffer(chunk);
+		} else {
+			this.push(chunk);
+		}
+
+		callback();
+	}
+
+	public handleFinished(): void {
+		this.is_closed = true;
+
+		if (!this.isBuffering()) {
+			this.pushClosed();
+		}
+	}
+
+	private pushClosed(): void {
+		this.push(null);
+	}
+
+	private emptyBuffer(): void {
+		this.push(this.buffer);
+		this.buffer = undefined;
+	}
+
+	private isClosed(): boolean {
+		return this.is_closed;
+	}
+
+	private isBuffering(): boolean {
+		return this.buffer !== undefined;
+	}
+
+	private addToBuffer(chunk: Buffer): void {
+		if (this.buffer === undefined) {
+			throw new Error('Tried to read buffer, but it was not set');
+		}
+
+		this.buffer = Buffer.concat([this.buffer, chunk]);
+	}
+}
+
+export default BufferStream;

package/src/lib/http/enum/content-type.ts

@@ -0,0 +1,19 @@
+enum ContentType {
+	ANY = '*/*',
+	CSS = 'text/css',
+	GIF = 'image/gif',
+	HTML = 'text/html',
+	// I am loathe to have a hard-coded reference to Microsoft in the codebase...
+	ICO = 'image/vnd.microsoft.icon',
+	JPEG = 'image/jpeg',
+	JS = 'text/javascript',
+	JSON = 'application/json',
+	MP3 = 'audio/mpeg',
+	MULTIPART = 'multipart/form-data',
+	PNG = 'image/png',
+	TEXT = 'text/plain',
+	URL_ENCODED = 'application/x-www-form-urlencoded',
+	WAV = 'audio/wav'
+}
+
+export default ContentType;

package/src/lib/http/enum/cookie-attribute.ts

@@ -0,0 +1,11 @@
+enum CookieAttribute {
+	DOMAIN = 'domain',
+	EXPIRES = 'expires',
+	HTTPONLY = 'httponly',
+	PATH = 'path',
+	SECURE = 'secure',
+	SESSION = 'session',
+	SAMESITE = 'samesite'
+}
+
+export default CookieAttribute;

package/src/lib/http/enum/header.ts

@@ -0,0 +1,29 @@
+enum HttpHeader {
+	ACCEPT = 'accept',
+	ACCESS_CONTROL_ALLOW_CREDENTIALS = 'access-control-allow-credentials',
+	ACCESS_CONTROL_ALLOW_HEADERS = 'access-control-allow-headers',
+	ACCESS_CONTROL_ALLOW_METHODS = 'access-control-allow-methods',
+	ACCESS_CONTROL_ALLOW_ORIGIN = 'access-control-allow-origin',
+	ACCESS_CONTROL_REQUEST_HEADERS = 'access-control-request-headers',
+	AUTHORIZATION = 'authorization',
+	CONNECTION = 'connection',
+	CONTENT_LENGTH = 'content-length',
+	CONTENT_SECURITY_POLICY = 'content-security-policy',
+	CONTENT_TYPE = 'content-type',
+	COOKIE = 'cookie',
+	DATE = 'date',
+	ETAG = 'etag',
+	HOST = 'host',
+	IF_MODIFIED_SINCE = 'if-modified-since',
+	IF_NONE_MATCH = 'if-none-match',
+	LAST_MODIFIED = 'last-modified',
+	LOCATION = 'location',
+	ORIGIN = 'origin',
+	REFERER = 'referer',
+	SET_COOKIE = 'set-cookie',
+	TRANSFER_ENCODING = 'transfer-encoding',
+	USER_AGENT = 'user-agent',
+	X_FORWARDED_FOR = 'x-forwarded-for'
+}
+
+export default HttpHeader;

package/src/lib/http/enum/method.ts

@@ -0,0 +1,11 @@
+enum Method {
+	GET = 'GET',
+	HEAD = 'HEAD',
+	PATCH = 'PATCH',
+	POST = 'POST',
+	PUT = 'PUT',
+	DELETE = 'DELETE',
+	OPTIONS = 'OPTIONS'
+}
+
+export default Method;

package/src/lib/http/enum/same-site-policy.ts

@@ -0,0 +1,7 @@
+enum SameSitePolicy {
+	STRICT = 'strict',
+	LAX = 'lax',
+	NONE = 'none'
+}
+
+export default SameSitePolicy;

package/src/lib/http/enum/status-code.ts

@@ -0,0 +1,9 @@
+import {HttpStatusCode} from 'lib/network';
+
+// Wondering why this is in lib/network instead of here?
+// This module has some dependencies that rely on these status codes.
+// This way, those dependencies can import lib/network instead.
+
+export default HttpStatusCode;
+
+

package/src/lib/http/factory/body-parser.ts

@@ -0,0 +1,55 @@
+import HTTP from 'http';
+import Stream from 'stream';
+
+import BodyParser from 'lib/http/parser/body';
+import ContentType from 'lib/http/enum/content-type';
+import JsonBodyParser from 'lib/http/parser/body/json';
+import MultipartBodyParser from 'lib/http/parser/body/multipart';
+import UrlEncodedBodyParser from 'lib/http/parser/body/url-encoded';
+
+class BodyParserFactory {
+	private stream: Stream.Readable;
+	private content_type: ContentType;
+	private native_request: HTTP.IncomingMessage;
+
+	public constructor(
+		stream: Stream.Readable,
+		content_type: ContentType,
+		native_request: HTTP.IncomingMessage
+	) {
+		this.stream = stream;
+		this.content_type = content_type;
+		this.native_request = native_request;
+	}
+
+	public getParser(): BodyParser {
+		const stream = this.getStream();
+		const content_type = this.getContentType();
+		const native_request = this.getNativeRequest();
+
+		switch (content_type) {
+			case ContentType.URL_ENCODED:
+				return new UrlEncodedBodyParser(stream);
+			case ContentType.MULTIPART:
+				return new MultipartBodyParser(stream, native_request);
+
+			case ContentType.JSON:
+			default:
+				return new JsonBodyParser(stream);
+		}
+	}
+
+	private getStream(): Stream.Readable {
+		return this.stream;
+	}
+
+	private getContentType(): ContentType {
+		return this.content_type;
+	}
+
+	private getNativeRequest(): HTTP.IncomingMessage {
+		return this.native_request;
+	}
+}
+
+export default BodyParserFactory;

package/src/lib/http/index.ts

@@ -0,0 +1,24 @@
+export {default as ContentType} from 'lib/http/enum/content-type';
+export {default as CookieAttribute} from 'lib/http/enum/cookie-attribute';
+export {default as HttpHeader} from 'lib/http/enum/header';
+export {default as HttpMethod} from 'lib/http/enum/method';
+export {default as StatusCode} from 'lib/http/enum/status-code';
+
+export {default as IncomingRequest} from 'lib/http/request/incoming';
+export {default as OutgoingRequest} from 'lib/http/request/outgoing';
+export {default as IncomingResponse} from 'lib/http/response/incoming';
+export {default as OutgoingResponse} from 'lib/http/response/outgoing';
+
+export {default as HeaderMap} from 'lib/http/type/header-map';
+export {default as QueryData} from 'lib/http/type/query-data';
+export {default as PathParameters} from 'lib/http/type/path-parameters';
+export {default as TransactionData} from 'lib/http/type/transaction-data';
+
+export {default as NetworkLibrary} from 'lib/http/interface/network-library';
+
+export {default as CookieSerializer} from 'lib/http/serializer/cookie';
+export {default as QueryDataSerializer} from 'lib/http/serializer/query-data';
+export {default as BasicAuthHeaderParser} from 'lib/http/parser/basic-auth-header';
+
+export {default as getContentTypeForExtension} from 'lib/http/utility/get-content-type-for-extension';
+export {default as getStatusCodeForError} from 'lib/http/utility/get-status-code-for-error';