@fc3/mmcadi 0.1.0

package/src/lib/array/add.ts

@@ -0,0 +1,10 @@
+function add<T>(array: T[], value: T): boolean {
+	if (!array.includes(value)) {
+		array.push(value);
+		return true;
+	}
+
+	return false;
+}
+
+export default add;

package/src/lib/array/assert-is-empty.ts

@@ -0,0 +1,23 @@
+import {GenericError} from 'lib/errors';
+
+import isEmpty from 'lib/array/is-empty';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function assertIsEmpty(array: any[], label?: string): void {
+	if (isEmpty(array)) {
+		return;
+	}
+
+	const serialized_array = JSON.stringify(array);
+
+	if (label === undefined) {
+		label = 'array';
+	}
+
+	throw new GenericError(`
+		Expected ${label} to be empty, but it had the following elements:
+		${serialized_array}
+	`);
+}
+
+export default assertIsEmpty;

package/src/lib/array/clone.ts

@@ -0,0 +1,5 @@
+function clone<T>(array: T[]): T[] {
+	return Array.prototype.slice.call(array);
+}
+
+export default clone;

package/src/lib/array/difference.ts

@@ -0,0 +1,8 @@
+// Returns all the elements in A that are not in B.
+function difference<T>(a: T[], b: T[]): T[] {
+	return a.filter((element) => {
+		return b.includes(element) === false;
+	});
+}
+
+export default difference;

package/src/lib/array/empty.ts

@@ -0,0 +1,6 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function empty(array: any[]): void {
+	array.splice(0, array.length);
+}
+
+export default empty;

package/src/lib/array/equal.ts

@@ -0,0 +1,24 @@
+// TODO: should this be `unknown` instead of `any`?
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function equal(array_a: any[], array_b: any[]): boolean {
+	if (array_a.length !== array_b.length) {
+		return false;
+	}
+
+	let index = 0;
+
+	while (index < array_a.length) {
+		const array_a_value = array_a[index];
+		const array_b_value = array_b[index];
+
+		if (array_a_value !== array_b_value) {
+			return false;
+		}
+
+		index++;
+	}
+
+	return true;
+}
+
+export default equal;

package/src/lib/array/get-first-value.ts

@@ -0,0 +1,5 @@
+function getFirstValue<T>(array: T[]): T | undefined {
+	return array[0];
+}
+
+export default getFirstValue;

package/src/lib/array/get-last-value.ts

@@ -0,0 +1,5 @@
+function getLastValue<T>(array: T[]): T | undefined {
+	return array[array.length - 1];
+}
+
+export default getLastValue;

package/src/lib/array/get-max-value.ts

@@ -0,0 +1,5 @@
+function getMaxValue(values: number[]): number {
+	return Math.max.apply(Math, values);
+}
+
+export default getMaxValue;

package/src/lib/array/get-value-after.ts

@@ -0,0 +1,23 @@
+import getFirstValue from 'lib/array/get-first-value';
+
+function getValueAfter<T>(array: T[], item: T, wrap = false): T | undefined {
+	let index = array.indexOf(item);
+
+	if (index === -1) {
+		return undefined;
+	}
+
+	index++;
+
+	if (index === array.length) {
+		if (wrap) {
+			return getFirstValue(array);
+		} else {
+			return undefined;
+		}
+	}
+
+	return array[index];
+}
+
+export default getValueAfter;

package/src/lib/array/get-value-before.ts

@@ -0,0 +1,23 @@
+import getLastValue from 'lib/array/get-last-value';
+
+function getValueBefore<T>(array: T[], item: T, wrap = false): T | undefined {
+	let index = array.indexOf(item);
+
+	if (index === -1) {
+		return undefined;
+	}
+
+	index--;
+
+	if (index === -1) {
+		if (wrap) {
+			return getLastValue(array);
+		} else {
+			return undefined;
+		}
+	}
+
+	return array[index];
+}
+
+export default getValueBefore;

package/src/lib/array/get-values-between.ts

@@ -0,0 +1,18 @@
+import {NotFoundError} from 'lib/errors';
+
+function getValuesBetween<T>(array: T[], first_item: T, last_item: T): T[] {
+	const first_item_index = array.indexOf(first_item);
+	const last_item_index = array.indexOf(last_item);
+
+	if (first_item_index === -1) {
+		throw new NotFoundError(`Unable to find first item ${first_item} in array`);
+	}
+
+	if (last_item_index === -1) {
+		throw new NotFoundError(`Unable to find last item ${last_item} in array`);
+	}
+
+	return array.slice(first_item_index, last_item_index + 1);
+}
+
+export default getValuesBetween;

package/src/lib/array/index.ts

@@ -0,0 +1,5 @@
+export {default as clone} from 'lib/array/clone';
+export {default as getLastValue} from 'lib/array/get-last-value';
+export {default as getFirstValue} from 'lib/array/get-first-value';
+export {default as getMaxValue} from 'lib/array/get-max-value';
+export {default as equal} from 'lib/array/equal';

package/src/lib/array/is-empty.ts

@@ -0,0 +1,6 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isEmpty(array: any[]): boolean {
+	return array.length === 0;
+}
+
+export default isEmpty;

package/src/lib/array/remove.ts

@@ -0,0 +1,19 @@
+function remove<T>(array: T[], value: T): boolean {
+	let index = 0;
+	let hit = false;
+
+	while (index < array.length) {
+		const element = array[index];
+
+		if (element === value) {
+			array.splice(index, 1);
+			hit = true;
+		} else {
+			index++;
+		}
+	}
+
+	return hit;
+}
+
+export default remove;

package/src/lib/array/sum.ts

@@ -0,0 +1,11 @@
+function sum(values: number[]): number {
+	let result = 0;
+
+	values.forEach((value) => {
+		result += value;
+	});
+
+	return result;
+}
+
+export default sum;

package/src/lib/array/unique.ts

@@ -0,0 +1,13 @@
+function unique<T>(array: T[]): T[] {
+	const result: T[] = [];
+
+	array.forEach((value) => {
+		if (!result.includes(value)) {
+			result.push(value);
+		}
+	});
+
+	return result;
+}
+
+export default unique;

package/src/lib/environment/bootstrap.ts

@@ -0,0 +1 @@
+throw new Error('Not implemented');

package/src/lib/environment/enum/environment-type.ts

@@ -0,0 +1,8 @@
+enum EnvironmentType {
+	DEVELOPMENT = 'development',
+	PRODUCTION = 'production',
+	STAGING = 'staging',
+	TEST = 'test'
+}
+
+export default EnvironmentType;

package/src/lib/environment/enum/service-type.ts

@@ -0,0 +1,5 @@
+enum ServiceType {
+	API = 'api'
+}
+
+export default ServiceType;

package/src/lib/environment/index.ts

@@ -0,0 +1,7 @@
+export {default as EnvironmentType} from 'lib/environment/enum/environment-type';
+export {default as ServiceType} from 'lib/environment/enum/service-type';
+export {default as isProductionOrStaging} from 'lib/environment/utility/is-production-or-staging';
+export {default as isProduction} from 'lib/environment/utility/is-production';
+export {default as isDevelopment} from 'lib/environment/utility/is-development';
+export {default as isBrowser} from 'lib/environment/utility/is-browser';
+export {default as getEnvironmentType} from 'lib/environment/utility/get-environment-type';

package/src/lib/environment/utility/get-environment-type.ts

@@ -0,0 +1,28 @@
+import isBrowser from 'lib/environment/utility/is-browser';
+import EnvironmentType from 'lib/environment/enum/environment-type';
+
+function getEnvironmentType(): EnvironmentType {
+	if (isBrowser()) {
+		if (window.location.hostname.includes('saffron.gg')) {
+			return EnvironmentType.PRODUCTION;
+		} else {
+			return EnvironmentType.DEVELOPMENT;
+		}
+	}
+
+	switch (process.env.NODE_ENV) {
+		case 'development':
+		case undefined:
+			return EnvironmentType.DEVELOPMENT;
+		case 'production':
+			return EnvironmentType.PRODUCTION;
+		case 'staging':
+			return EnvironmentType.STAGING;
+		case 'test':
+			return EnvironmentType.TEST;
+		default:
+			throw new Error(`Unsupported environment type: ${process.env.NODE_ENV}`);
+	}
+}
+
+export default getEnvironmentType;

package/src/lib/environment/utility/is-browser.ts

@@ -0,0 +1,5 @@
+function isBrowser(): boolean {
+	return typeof window !== 'undefined';
+}
+
+export default isBrowser;

package/src/lib/environment/utility/is-development.ts

@@ -0,0 +1,10 @@
+import EnvironmentType from 'lib/environment/enum/environment-type';
+import getEnvironmentType from 'lib/environment/utility/get-environment-type';
+
+function isDevelopment(): boolean {
+	const environment_type = getEnvironmentType();
+
+	return environment_type === EnvironmentType.DEVELOPMENT;
+}
+
+export default isDevelopment;

package/src/lib/environment/utility/is-production-or-staging.ts

@@ -0,0 +1,8 @@
+import isProduction from 'lib/environment/utility/is-production';
+import isStaging from 'lib/environment/utility/is-staging';
+
+function isProductionOrStaging(): boolean {
+	return isProduction() || isStaging();
+}
+
+export default isProductionOrStaging;

package/src/lib/environment/utility/is-production.ts

@@ -0,0 +1,10 @@
+import EnvironmentType from 'lib/environment/enum/environment-type';
+import getEnvironmentType from 'lib/environment/utility/get-environment-type';
+
+function isProduction(): boolean {
+	const environment_type = getEnvironmentType();
+
+	return environment_type === EnvironmentType.PRODUCTION;
+}
+
+export default isProduction;

package/src/lib/environment/utility/is-staging.ts

@@ -0,0 +1,10 @@
+import EnvironmentType from 'lib/environment/enum/environment-type';
+import getEnvironmentType from 'lib/environment/utility/get-environment-type';
+
+function isStaging(): boolean {
+	const environment_type = getEnvironmentType();
+
+	return environment_type === EnvironmentType.STAGING;
+}
+
+export default isStaging;

package/src/lib/errors/enum/error-type.ts

@@ -0,0 +1,13 @@
+enum ErrorType {
+	CONFLICT = 'conflict',
+	GENERIC = 'generic',
+	OMITTED = 'omitted',
+	INVALID = 'invalid',
+	NOT_ALLOWED = 'not_allowed',
+	NOT_FOUND = 'not_found',
+	NOT_IMPLEMENTED = 'not_implemented',
+	TIMEOUT = 'timeout',
+	UNAUTHORIZED = 'unauthorized'
+}
+
+export default ErrorType;

package/src/lib/errors/error/base.ts

@@ -0,0 +1,40 @@
+import {PosixErrorCode} from 'lib/process';
+
+import ErrorType from 'lib/errors/enum/error-type';
+import ErrorData from 'lib/errors/type/error-data';
+
+abstract class BaseError extends Error {
+	public code: PosixErrorCode | null;
+
+	public constructor(message: string, code?: PosixErrorCode | null) {
+		message = message.replace(/\s+/g, ' ').trim();
+
+		super(message);
+
+		this.code = code || null;
+	}
+
+	public getMessage(): string {
+		return this.message;
+	}
+
+	public getCode(): PosixErrorCode | null {
+		return this.code;
+	}
+
+	public getData(): ErrorData {
+		const error_type = this.getType();
+		const code = this.getCode();
+		const message = this.getMessage();
+
+		return {
+			error_type,
+			code,
+			message
+		};
+	}
+
+	public abstract getType(): ErrorType;
+}
+
+export default BaseError;

package/src/lib/errors/error/conflict.ts

@@ -0,0 +1,16 @@
+import {PosixErrorCode} from 'lib/process';
+
+import BaseError from 'lib/errors/error/base';
+import ErrorType from 'lib/errors/enum/error-type';
+
+class ConflictError extends BaseError {
+	public constructor(message?: string, code?: PosixErrorCode | null) {
+		super(message || 'Something went wrong', code);
+	}
+
+	public getType(): ErrorType {
+		return ErrorType.CONFLICT;
+	}
+}
+
+export default ConflictError;

package/src/lib/errors/error/generic.ts

@@ -0,0 +1,23 @@
+import {PosixErrorCode} from 'lib/process';
+
+import BaseError from 'lib/errors/error/base';
+import CodedError from 'lib/errors/type/coded-error';
+import ErrorType from 'lib/errors/enum/error-type';
+
+class GenericError extends BaseError {
+	public static fromNativeError(error: Error): GenericError {
+		const coded_error = error as CodedError;
+
+		return new GenericError(coded_error.message, coded_error.code);
+	}
+
+	public constructor(message?: string, code?: PosixErrorCode | null) {
+		super(message || 'Something went wrong.', code);
+	}
+
+	public getType(): ErrorType {
+		return ErrorType.GENERIC;
+	}
+}
+
+export default GenericError;

package/src/lib/errors/error/invalid.ts

@@ -0,0 +1,14 @@
+import BaseError from 'lib/errors/error/base';
+import ErrorType from 'lib/errors/enum/error-type';
+
+class InvalidError extends BaseError {
+	public constructor(message?: string) {
+		super(message || 'The specified data is invalid.');
+	}
+
+	public getType(): ErrorType {
+		return ErrorType.INVALID;
+	}
+}
+
+export default InvalidError;

package/src/lib/errors/error/invariant-violation.ts

@@ -0,0 +1,5 @@
+import GenericError from 'lib/errors/error/generic';
+
+class InvariantViolation extends GenericError {}
+
+export default InvariantViolation;

package/src/lib/errors/error/not-allowed.ts

@@ -0,0 +1,14 @@
+import BaseError from 'lib/errors/error/base';
+import ErrorType from 'lib/errors/enum/error-type';
+
+class NotAllowedError extends BaseError {
+	public constructor(message?: string) {
+		super(message || 'Not allowed');
+	}
+
+	public getType(): ErrorType {
+		return ErrorType.NOT_ALLOWED;
+	}
+}
+
+export default NotAllowedError;

package/src/lib/errors/error/not-found.ts

@@ -0,0 +1,16 @@
+import {PosixErrorCode} from 'lib/process';
+
+import BaseError from 'lib/errors/error/base';
+import ErrorType from 'lib/errors/enum/error-type';
+
+class NotFoundError extends BaseError {
+	public constructor(message?: string, code?: PosixErrorCode | null) {
+		super(message || 'The desired file or resource was not found', code);
+	}
+
+	public getType(): ErrorType {
+		return ErrorType.NOT_FOUND;
+	}
+}
+
+export default NotFoundError;

package/src/lib/errors/error/not-implemented.ts

@@ -0,0 +1,20 @@
+import BaseError from 'lib/errors/error/base';
+import ErrorType from 'lib/errors/enum/error-type';
+
+class NotImplementedError extends BaseError {
+	public constructor(message?: string) {
+		if (message === undefined) {
+			message = 'Not implemented';
+		} else {
+			message = `Not implemented: ${message}`;
+		}
+
+		super(message);
+	}
+
+	public getType(): ErrorType {
+		return ErrorType.NOT_IMPLEMENTED;
+	}
+}
+
+export default NotImplementedError;

package/src/lib/errors/error/omitted.ts

@@ -0,0 +1,14 @@
+import ErrorType from 'lib/errors/enum/error-type';
+import InvalidError from 'lib/errors/error/invalid';
+
+class OmittedError extends InvalidError {
+	public constructor(message?: string) {
+		super(message || 'Must specify a value');
+	}
+
+	public getType(): ErrorType {
+		return ErrorType.OMITTED;
+	}
+}
+
+export default OmittedError;

package/src/lib/errors/error/timeout.ts

@@ -0,0 +1,14 @@
+import BaseError from 'lib/errors/error/base';
+import ErrorType from 'lib/errors/enum/error-type';
+
+class TimeoutError extends BaseError {
+	public constructor(message?: string) {
+		super(message || 'Operation timed out');
+	}
+
+	public getType(): ErrorType {
+		return ErrorType.TIMEOUT;
+	}
+}
+
+export default TimeoutError;

package/src/lib/errors/error/unauthorized.ts

@@ -0,0 +1,14 @@
+import BaseError from 'lib/errors/error/base';
+import ErrorType from 'lib/errors/enum/error-type';
+
+class UnauthorizedError extends BaseError {
+	public constructor(message?: string) {
+		super(message || 'Permission denied');
+	}
+
+	public getType(): ErrorType {
+		return ErrorType.UNAUTHORIZED;
+	}
+}
+
+export default UnauthorizedError;

package/src/lib/errors/index.ts

@@ -0,0 +1,18 @@
+export {default as BaseError} from 'lib/errors/error/base';
+export {default as ConflictError} from 'lib/errors/error/conflict';
+export {default as GenericError} from 'lib/errors/error/generic';
+export {default as InvalidError} from 'lib/errors/error/invalid';
+export {default as NotFoundError} from 'lib/errors/error/not-found';
+export {default as NotImplementedError} from 'lib/errors/error/not-implemented';
+export {default as TimeoutError} from 'lib/errors/error/timeout';
+export {default as UnauthorizedError} from 'lib/errors/error/unauthorized';
+export {default as InvariantViolation} from 'lib/errors/error/invariant-violation';
+
+export {default as wrapError} from 'lib/errors/utility/wrap-error';
+export {default as ErrorType} from 'lib/errors/enum/error-type';
+export {default as createErrorFromAmbiguousJsonData} from 'lib/errors/utility/create-error-from-ambiguous-json-data';
+export {default as matchesPosixErrorCode} from 'lib/errors/utility/matches-posix-error-code';
+export {default as getErrorTypeForStatusCode} from 'lib/errors/utility/get-error-type-for-status-code';
+export {default as createErrorForErrorType} from 'lib/errors/utility/create-error-for-error-type';
+
+export {default as invariant} from 'lib/errors/sugar/invariant';

package/src/lib/errors/sugar/invariant.ts

@@ -0,0 +1,7 @@
+import InvariantViolation from 'lib/errors/error/invariant-violation';
+
+function invariant(message: string): void {
+	throw new InvariantViolation(message);
+}
+
+export default invariant;

package/src/lib/errors/type/coded-error.ts

@@ -0,0 +1,7 @@
+import {PosixErrorCode} from 'lib/process';
+
+interface CodedError extends Error {
+	readonly code: PosixErrorCode;
+}
+
+export default CodedError;

package/src/lib/errors/type/error-data.ts

@@ -0,0 +1,11 @@
+import {PosixErrorCode} from 'lib/process';
+
+import ErrorType from 'lib/errors/enum/error-type';
+
+interface ErrorData {
+	readonly error_type: ErrorType;
+	readonly message: string;
+	readonly code: PosixErrorCode | null;
+}
+
+export default ErrorData;