mlcl 1.0.0

package/build/commands/utilities/ts-to-js.js

@@ -0,0 +1,344 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import ts from 'typescript';
+import prettier from 'prettier';
+import process from 'process';
+const __dirname = fileURLToPath(path.dirname(import.meta.url));
+/**
+ * Returns the name of some node.
+ */
+const getName = (source, node) => {
+    let name = (node.name && node.name.escapedText)
+        || (node.parameters && source.substring(node.parameters.pos, node.parameters.end));
+    // Change type [key: string] to {...} so it will be parsed by JSDoc.
+    if (name === 'key: string') {
+        return '{...}';
+    }
+    return name;
+};
+/**
+ * Returns the name of some type.
+ */
+const getTypeName = (source, type) => {
+    let typeName = ``;
+    if (!type) {
+        return `any`;
+    }
+    if (type.typeName && type.typeName.escapedText) {
+        typeName = type.typeName.escapedText;
+        if (type.typeArguments && type.typeArguments.length) {
+            const args = type.typeArguments.map(subType => getTypeName(source, subType)).join(', ');
+            typeName = `${typeName}<${args}>`;
+        }
+    }
+    else if (ts.isFunctionTypeNode(type) || ts.isFunctionLike(type)) {
+        typeName = 'function';
+    }
+    else if (ts.isArrayTypeNode(type)) {
+        typeName = 'Array';
+    }
+    else if (type.types) {
+        typeName = type.types.map(subType => getTypeName(source, subType)).join(' | ');
+    }
+    else if (type.members && type.members.length) {
+        typeName = 'object';
+    }
+    else {
+        typeName = source.substring(type.pos, type.end).trim();
+    }
+    typeName = typeName.replace(/`/g, `'`);
+    typeName = typeName.replace(`['`, `#`).replace(`']`, ``);
+    typeName = typeName.replace(/keyof .+/g, `string`);
+    return typeName;
+};
+/**
+ * Returns the JSDoc `@param` tag for some parameter.
+ */
+const getJSDocParamTag = (source, parameter) => {
+    let parameterName = getName(source, parameter);
+    const parameterComment = (parameter.jsDoc && parameter.jsDoc[0] && parameter.jsDoc[0].comment) || '';
+    if (parameter.questionToken) {
+        parameterName = ['[', parameterName, ']'].join('');
+    }
+    return `@param {${getTypeName(source, parameter.type)}} ${parameterName}${parameterComment ? ` ${parameterComment}` : ``}`;
+};
+/**
+ * Returns JSDoc `@property` tags for some type.
+ */
+const getJSDocPropertyTags = (source, type, tags = [], parentName = '') => {
+    // Type could be an array of types like: `{sth: 1} | string` so parse each type separately.
+    const typesToCheck = [type];
+    if (type.types && type.types.length) {
+        typesToCheck.push(...type.types);
+    }
+    typesToCheck.forEach(type => {
+        // Handling array defined like this: {element1: 'something'}[]
+        if (ts.isArrayTypeNode(type) && type.elementType) {
+            getJSDocPropertyTags(source, type.elementType, tags, parentName ? parentName + '[]' : '[]');
+        }
+        // Handling Array<{element1: 'somethin'}>
+        if (type.typeName && type.typeName.escapedText === 'Array') {
+            if (type.typeArguments && type.typeArguments.length) {
+                type.typeArguments.forEach(subType => {
+                    getJSDocPropertyTags(source, subType, tags, parentName ? parentName + '[]' : '');
+                });
+            }
+        }
+        // Handling {property1: "value"}
+        (type.members || []).filter(m => ts.isTypeElement(m)).forEach(member => {
+            let memberName = getName(source, member);
+            const memberComment = (member.jsDoc && member.jsDoc[0] && member.jsDoc[0].comment) || '';
+            const members = member.type.members || [];
+            const memberTypeName = members.length ? 'object' : getTypeName(source, member.type);
+            if (parentName) {
+                memberName = [parentName, memberName].join('.');
+            }
+            tags.push(`@property {${memberTypeName}} ${member.questionToken ? `[${memberName}]` : memberName}${memberComment ? ` ${memberComment}` : ``}`);
+            getJSDocPropertyTags(source, member.type, tags, memberName);
+        });
+    });
+    return tags;
+};
+/**
+ * Returns JSDoc comment lines and a method to append comment lines.
+ */
+const useCommentLines = (source, jsDocNode) => {
+    const commentLines = jsDocNode
+        ? source.substring(jsDocNode.pos, jsDocNode.end).split(/(\n|\r|\r\n)/).filter(line => line.trim().length > 0)
+        : [`/**`, ` */`];
+    let appendedAtLeastOnce = jsDocNode ? false : true;
+    const shouldUpdate = { current: false };
+    const appendComment = line => {
+        let args = [commentLines.length - 1, 0];
+        if (!appendedAtLeastOnce) {
+            appendedAtLeastOnce = true;
+            args = args.concat(` *`);
+        }
+        args = args.concat([].concat(line).map(line => ` * ${line}`));
+        commentLines.splice.apply(commentLines, args);
+        shouldUpdate.current = true;
+    };
+    return [commentLines, appendComment, shouldUpdate];
+};
+/**
+ * Updates JSDoc comments based on the type definitions.
+ */
+const updateJSDocComments = (source, filename, modulePath) => {
+    const sourceFile = ts.createSourceFile(filename, source, ts.ScriptTarget.Latest, true);
+    let updatedSource = source;
+    let tempConstantIndex = 1;
+    const isTest = modulePath.includes(`/__tests__/`) && !/\.(spec|test)\.tsx?$/.test(filename);
+    if (modulePath && !isTest) {
+        if (!updatedSource.includes(`* @module`)) {
+            updatedSource = `${updatedSource}\n\n/** @module ${modulePath} */`;
+        }
+    }
+    for (const statement of sourceFile.statements) {
+        const name = getName(source, statement);
+        const [commentLines, appendComment, shouldUpdate] = useCommentLines(source, statement.jsDoc && statement.jsDoc[0]);
+        const appendMemberOf = () => {
+            if (modulePath && !isTest) {
+                appendComment([
+                    `@memberof module:${modulePath}`,
+                    ``
+                ]);
+            }
+        };
+        let addCommentAfter = false;
+        const declaration = statement.declarationList
+            && statement.declarationList.declarations
+            && statement.declarationList.declarations[0];
+        const functionParameters = declaration
+            && declaration.initializer
+            && declaration.initializer.parameters;
+        if (ts.isTypeAliasDeclaration(statement)) {
+            addCommentAfter = true;
+            if (ts.isFunctionTypeNode(statement.type)) {
+                appendMemberOf();
+                appendComment(`@typedef {function} ${name}`);
+                statement.type.parameters.forEach(parameter => {
+                    appendComment(getJSDocParamTag(source, parameter));
+                });
+            }
+            if (ts.isTypeLiteralNode(statement.type)) {
+                appendMemberOf();
+                appendComment(`@typedef {object} ${name}`);
+                getJSDocPropertyTags(source, statement.type).forEach(appendComment);
+            }
+            if (ts.isIntersectionTypeNode(statement.type)) {
+                appendMemberOf();
+                appendComment(`@typedef {object} ${name}`);
+                getJSDocPropertyTags(source, statement.type).forEach(appendComment);
+            }
+        }
+        else if (ts.isInterfaceDeclaration(statement)) {
+            addCommentAfter = true;
+            appendMemberOf();
+            appendComment(`@typedef ${name}`);
+            statement.members.forEach(member => {
+                const memberName = getName(source, member);
+                appendComment(`@property {${getTypeName(source, member.type)}} ${member.questionToken ? `[${memberName}]` : memberName}`);
+            });
+        }
+        else if (ts.isClassDeclaration(statement)) {
+            const className = getName(source, statement);
+            const memberComments = [];
+            statement.members.forEach(member => {
+                if (!ts.isPropertyDeclaration(member)) {
+                    return;
+                }
+                const modifiers = (member.modifiers || []).map(m => m.getText({ text: source }));
+                modifiers.forEach(m => {
+                    if (['private', 'public', 'protected'].includes(m)) {
+                        memberComments.push(`@${m}`);
+                    }
+                });
+                if (member.type) {
+                    memberComments.push(`@type {${getTypeName(source, member.type)}}`);
+                }
+                if (modifiers.find((m => m === 'static'))) {
+                    memberComments.push(`${className}.${getName(source, member)}`);
+                }
+                else {
+                    memberComments.push(`${className}.prototype.${getName(source, member)}`);
+                }
+                memberComments.forEach(appendComment);
+            });
+        }
+        else if (declaration && declaration.type) {
+            appendMemberOf();
+            appendComment(`@type {${getTypeName(source, declaration.type)}}`);
+        }
+        else if (functionParameters) {
+            appendMemberOf();
+            functionParameters.forEach(parameter => {
+                appendComment(getJSDocParamTag(source, parameter));
+            });
+        }
+        if (shouldUpdate.current) {
+            const newCommentBlock = commentLines.join(`\n`); // TODO .replace(/```ts/g, '```js')
+            const text = statement.getText().trim();
+            const fullText = statement.getFullText().trim();
+            if (filename.split(/\/|\\/).pop() === `types.ts` || !fullText || updatedSource.indexOf(fullText) < 0) {
+                updatedSource = `${updatedSource}\n\n${newCommentBlock}`;
+            }
+            else if (addCommentAfter) {
+                updatedSource = updatedSource.replace(statement.jsDoc ? fullText : text, `${text}\n\n${newCommentBlock}\nconst ___temp${tempConstantIndex++} = null`);
+            }
+            else {
+                updatedSource = updatedSource.replace(statement.jsDoc ? fullText : text, `${newCommentBlock}\n${text}`);
+            }
+        }
+    }
+    return updatedSource;
+};
+/**
+ * Recursively walks through the directories and converts all .ts and .tsx files
+ * to .js and .jsx files with JSDoc type annotations based on the type definitions.
+ *
+ * All other files are copied as is.
+ */
+const tsToJs = (tsPath, jsPath, modulePath = '') => {
+    const files = fs.readdirSync(tsPath);
+    for (const file of files) {
+        const tsFile = path.join(tsPath, file);
+        const jsFile = path.join(jsPath, file.replace(/\.ts$/, '.js').replace(/\.tsx$/, '.jsx'));
+        const stats = fs.statSync(tsFile);
+        if (stats.isDirectory()) {
+            tsToJs(tsFile, jsFile, modulePath ? `${modulePath}/${file}` : file);
+            continue;
+        }
+        else if (!/\.tsx?$/.test(file)) {
+            // Ensure the directory exists.
+            if (!fs.existsSync(jsPath)) {
+                fs.mkdirSync(jsPath, { recursive: true });
+            }
+            fs.copyFileSync(tsFile, jsFile);
+            continue;
+        }
+        else if (/\.d\.ts$/.test(file)) {
+            continue;
+        }
+        let source = fs.readFileSync(tsFile, 'utf8');
+        if (source.includes(`/** @ts-only */`)) {
+            // Skip copying of files with this flag.
+            continue;
+        }
+        // Remove lines (usually type imports) containing the `// @ts-only` comment.
+        source = source.replace(/^(.*)\/\/ @ts-only(.*)(\r|\n|\r\n)/gm, ``);
+        // Ensure every module is covered.
+        source = source + `\n\n\nconst ___temp = null`;
+        // Add the necessary JSDoc comments based on the type definitions.
+        source = updateJSDocComments(source, tsFile, modulePath ? `${modulePath}/${file.replace(/\.tsx?$/, ``)}` : file.replace(/\.tsx?$/, ``));
+        // Preserve line spacing.
+        source = source.replace(/(\n\n|\r\r|\r\n\r\n)/g, '\n/* __NEWLINE__ */');
+        // Get transpiled ESM code.
+        source = ts.transpileModule(source, {
+            compilerOptions: {
+                target: ts.ScriptTarget.ESNext,
+                module: ts.ModuleKind.ESNext,
+                moduleResolution: ts.ModuleResolutionKind.NodeJs,
+                esModuleInterop: true,
+                strict: false,
+                jsx: /\.tsx$/.test(file) ? ts.JsxEmit.Preserve : ts.JsxEmit.None,
+                newLine: ts.NewLineKind.LineFeed,
+                removeComments: false,
+                pretty: true
+            }
+        }).outputText;
+        // Restore line spacing.
+        source = source.replace(/\/\* __NEWLINE__ \*\//g, '\n');
+        // Remove the temporary constants.
+        source = source.replace(/const ___temp(|[0-9]+) = null/g, '');
+        // Remove @typescript-eslint lines.
+        source = source.replace(/(\s|)(\/\/|\/\*) eslint-disable(|-next-line) @typescript-eslint\/.*?(\n|\r|\r\n)/gi, `\n`);
+        try {
+            // Make the code pretty again.
+            source = prettier.format(source, {
+                filepath: jsFile,
+                printWidth: 120,
+                semi: false,
+                singleQuote: true,
+                quoteProps: 'consistent',
+                jsxSingleQuote: true,
+                trailingComma: 'none'
+            });
+        }
+        catch (error) {
+            console.error(error);
+            console.log(tsFile);
+            console.log(source);
+        }
+        if (source.trim().length && source.trim() !== `export {}`) {
+            // Ensure the directory exists.
+            if (!fs.existsSync(jsPath)) {
+                fs.mkdirSync(jsPath, { recursive: true });
+            }
+            // Write the JavaScript file.
+            fs.writeFileSync(jsFile, source);
+        }
+    }
+};
+if (process.argv[2]) {
+    const tsPath = path.join(__dirname, process.argv[2], `src-ts`);
+    const jsPath = path.join(__dirname, process.argv[2], `src`);
+    if (fs.existsSync(jsPath)) {
+        fs.rmSync(jsPath, { recursive: true });
+    }
+    fs.mkdirSync(jsPath);
+    tsToJs(tsPath, jsPath);
+}
+else if (fs.existsSync(path.join(__dirname, `src-ts`))) {
+    const tsPath = path.join(__dirname, `src-ts`);
+    const jsPath = path.join(__dirname, `src`);
+    if (fs.existsSync(jsPath)) {
+        fs.rmSync(jsPath, { recursive: true });
+    }
+    fs.mkdirSync(jsPath);
+    tsToJs(tsPath, jsPath);
+}
+else {
+    console.info(`Usage is: node ts-to-js <dir>`);
+}

package/build/commands/version.js

@@ -0,0 +1,14 @@
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import path from 'path';
+const __dirname = fileURLToPath(path.dirname(import.meta.url));
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, `../../package.json`), `utf8`));
+/**
+ * Adds the `version` command to the program.
+ */
+export const version = (program) => {
+    program
+        .name(process.env.APP_NAME || pkg.name)
+        .description(pkg.description)
+        .version(process.env.APP_VERSION || pkg.version);
+};

package/build/commands/x-merge-json.js

@@ -0,0 +1,33 @@
+import fs from 'fs';
+import xdiff from 'xdiff';
+import detectIndent from 'detect-indent';
+const encoding = 'utf8';
+/**
+ * Adds the `x-merge-json` command to the program.
+ *
+ * Based off of https://github.com/jonatanpedersen/git-json-merge.
+ * Using our own implementation here because we're going to improve it later.
+ */
+export const xMergeJSON = (program) => {
+    program.command(`x-merge-json`)
+        .description(`git merge driver for JSON files`)
+        .argument(`[baseFilename]`, `base filename`)
+        .argument(`[oursFilename]`, `ours filename`)
+        .argument(`[theirsFilename]`, `theirs filename`)
+        .action(async (baseFilename, oursFilename, theirsFilename) => {
+        const baseJson = fs.readFileSync(baseFilename, encoding);
+        const base = JSON.parse(baseJson);
+        const baseIndent = detectIndent(baseJson).indent;
+        const oursJson = fs.readFileSync(oursFilename, encoding);
+        const ours = JSON.parse(oursJson);
+        const oursIndent = detectIndent(oursJson).indent;
+        const theirsJson = fs.readFileSync(theirsFilename, encoding);
+        const theirs = JSON.parse(theirsJson);
+        const theirsIndent = detectIndent(theirsJson).indent;
+        const indent = oursIndent !== baseIndent ? oursIndent : theirsIndent !== baseIndent ? theirsIndent : baseIndent;
+        const diff = xdiff.diff3(ours, base, theirs);
+        const newOurs = diff ? xdiff.patch(base, diff) : base;
+        const newOursJson = JSON.stringify(newOurs, null, indent);
+        fs.writeFileSync(oursFilename, newOursJson, encoding);
+    });
+};

package/build/config.js

@@ -0,0 +1,5 @@
+import * as utilities from './utilities/index.js';
+/**
+ * The current `.mlcl.json` (default) configuration state.
+ */
+export const config = utilities.readConfig();

package/build/environment.js

@@ -0,0 +1,80 @@
+/**
+ * This module helps with various sets of environment variables,
+ * using both `dotenv` and `env-cmd`.
+ *
+ * The `.env` file will be loaded via `dotenv.config()` and extended
+ * by the variables for the `NODE_ENV` key specified in `.env-cmdrc.json`.
+ *
+ * This also allows you to combine various sets of env vars using e.g.:
+ * ```
+ * ./node_modules/.bin/env-cmd -e development,something,etc npm run dev
+ * ```
+ *
+ * @see https://www.npmjs.com/package/dotenv
+ * @see https://www.npmjs.com/package/env-cmd
+ *
+ * @module
+ */
+import 'dotenv/config';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { pkg } from './pkg.js';
+const __dirname = fileURLToPath(path.dirname(import.meta.url));
+const defaultEnv = {
+    APP_ID: `mlcl`,
+    APP_NAME: pkg.name,
+    APP_VERSION: pkg.version,
+    APP_PLATFORM: `cli`,
+    API_ORIGIN: `https://api.molecule.dev`,
+    WEB_ORIGIN: `https://assemble.molecule.dev`,
+    LOG_LEVEL: `info`,
+};
+const defaultEnvCmdrc = {
+    'development': {
+        NODE_ENV: 'development',
+        API_ORIGIN: 'http://localhost:4000',
+        WEB_ORIGIN: 'http://localhost:3000',
+    },
+    'production': {
+        NODE_ENV: 'production',
+        API_ORIGIN: 'https://api.molecule.dev',
+        WEB_ORIGIN: 'https://assemble.molecule.dev',
+    },
+    'test': {
+        NODE_ENV: 'test',
+        LOG_LEVEL: 'silent',
+        API_ORIGIN: 'http://localhost:4000',
+        WEB_ORIGIN: 'http://localhost:3000',
+    }
+};
+if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = `production`;
+}
+for (const key in defaultEnv) {
+    process.env[key] = defaultEnv[key];
+}
+/**
+ * Sets the variables specified within each environment within `.env-cmdrc.json`.
+ */
+export const setVariables = (environments = [process.env.NODE_ENV || `production`]) => {
+    try {
+        const envCmdrcPath = path.join(__dirname, '../.env-cmdrc.json');
+        const envCmdrc = fs.existsSync(envCmdrcPath)
+            ? JSON.parse(fs.readFileSync(envCmdrcPath, 'utf8'))
+            : defaultEnvCmdrc;
+        for (const environment of environments) {
+            const variables = envCmdrc[environment];
+            if (variables) {
+                Object.assign(process.env, variables);
+            }
+            else {
+                console.warn(`Environment "${environment}" not found within .env-cmdrc.`);
+            }
+        }
+    }
+    catch (error) {
+    }
+};
+// Extend the environment variables using `.env-cmdrc.json`.
+setVariables();

package/build/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * Molecule.dev command line tools.
+ *
+ * @module
+ */
+import './environment.js';
+import { program } from 'commander';
+import * as commands from './commands/index.js';
+export * as API from './API/index.js';
+export * as commands from './commands/index.js';
+export * as utilities from './utilities/index.js';
+export * from './logger.js';
+export * from './pkg.js';
+export * from './repoConfig.js';
+export * from './userConfig.js';
+export * as types from './types/index.js';
+for (const commandKey in commands) {
+    if (typeof commands[commandKey] === `function`) {
+        commands[commandKey](program);
+    }
+}
+program.parse();

package/build/logger.js

@@ -0,0 +1,12 @@
+/**
+ * The logger, using `loglevel`.
+ *
+ * @see https://www.npmjs.com/package/loglevel
+ *
+ * @module
+ */
+import logger from 'loglevel';
+if (process.env.LOG_LEVEL) {
+    logger.setLevel(process.env.LOG_LEVEL);
+}
+export { logger };

package/build/pkg.js

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = fileURLToPath(path.dirname(import.meta.url));
+export const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, `../package.json`), `utf8`));

package/build/repoConfig copy.js

@@ -0,0 +1,5 @@
+import { readRepoConfig } from './utilities/readRepoConfig.js';
+/**
+ * The current repo's `mlcl` configuration state.
+ */
+export const repoConfig = readRepoConfig();

package/build/repoConfig.js

@@ -0,0 +1,5 @@
+import { readRepoConfig } from './utilities/readRepoConfig.js';
+/**
+ * The current repo's `mlcl` configuration state.
+ */
+export const repoConfig = readRepoConfig();

package/build/types/global.js

@@ -0,0 +1,6 @@
+/**
+ * Global type definitions.
+ *
+ * @module
+ */
+export {};

package/build/types/index.js

@@ -0,0 +1,6 @@
+/**
+ * Types used throughout `mlcl`.
+ *
+ * @module
+ */
+export * as global from './global.js';

package/build/userConfig.js

@@ -0,0 +1,5 @@
+import { readUserConfig } from './utilities/readUserConfig.js';
+/**
+ * The current user's `mlcl` configuration state.
+ */
+export const userConfig = readUserConfig();

package/build/utilities/__tests__/getErrorMessage.js

@@ -0,0 +1,26 @@
+import { getErrorMessage } from '../getErrorMessage.js';
+it(`returns a better "timed out" message`, () => {
+    expect(getErrorMessage({ code: `ETIMEDOUT` })).toBe(`Timed out`);
+});
+it(`returns a better "connection aborted" message`, () => {
+    expect(getErrorMessage({ code: `ECONNABORTED` })).toBe(`Connection aborted`);
+});
+it(`returns response data's error message`, () => {
+    expect(getErrorMessage({
+        response: {
+            data: {
+                error: `Username is required.`
+            }
+        }
+    })).toBe(`Username is required.`);
+});
+it(`returns error message`, () => {
+    expect(getErrorMessage(new Error(`Unexpected token`))).toBe(`Unexpected token`);
+});
+it(`returns the error if already a string`, () => {
+    expect(getErrorMessage(`Unexpected token`)).toBe(`Unexpected token`);
+});
+it(`returns null if no error`, () => {
+    expect(getErrorMessage()).toBe(null);
+    expect(getErrorMessage(null)).toBe(null);
+});

package/build/utilities/__tests__/timeAgo.js

@@ -0,0 +1,39 @@
+import { timeAgo } from '../timeAgo.js';
+const MINUTE = 60000 + 1;
+const HOUR = 3600000 + 1;
+const DAY = 86400000 + 1;
+const WEEK = 604800000 + 1;
+const YEAR = 31557600000 + 1;
+it(`returns "just now"`, () => {
+    expect(timeAgo(new Date().getTime())).toBe(`just now`);
+});
+it(`returns "minute(s)"`, () => {
+    expect(timeAgo(new Date().getTime() - MINUTE)).toBe(`1 minute ago`);
+    expect(timeAgo(new Date().getTime() - MINUTE * 2)).toBe(`2 minutes ago`);
+    expect(timeAgo(new Date().getTime() - MINUTE, true)).toBe(`1m ago`);
+    expect(timeAgo(new Date().getTime() - MINUTE * 2, true)).toBe(`2m ago`);
+});
+it(`returns "hour(s)"`, () => {
+    expect(timeAgo(new Date().getTime() - HOUR)).toBe(`1 hour ago`);
+    expect(timeAgo(new Date().getTime() - HOUR * 2)).toBe(`2 hours ago`);
+    expect(timeAgo(new Date().getTime() - HOUR, true)).toBe(`1h ago`);
+    expect(timeAgo(new Date().getTime() - HOUR * 2, true)).toBe(`2h ago`);
+});
+it(`returns "day(s)"`, () => {
+    expect(timeAgo(new Date().getTime() - DAY)).toBe(`1 day ago`);
+    expect(timeAgo(new Date().getTime() - DAY * 2)).toBe(`2 days ago`);
+    expect(timeAgo(new Date().getTime() - DAY, true)).toBe(`1d ago`);
+    expect(timeAgo(new Date().getTime() - DAY * 2, true)).toBe(`2d ago`);
+});
+it(`returns "week(s)"`, () => {
+    expect(timeAgo(new Date().getTime() - WEEK)).toBe(`1 week ago`);
+    expect(timeAgo(new Date().getTime() - WEEK * 2)).toBe(`2 weeks ago`);
+    expect(timeAgo(new Date().getTime() - WEEK, true)).toBe(`1w ago`);
+    expect(timeAgo(new Date().getTime() - WEEK * 2, true)).toBe(`2w ago`);
+});
+it(`returns "year(s)"`, () => {
+    expect(timeAgo(new Date().getTime() - YEAR)).toBe(`1 year ago`);
+    expect(timeAgo(new Date().getTime() - YEAR * 2)).toBe(`2 years ago`);
+    expect(timeAgo(new Date().getTime() - YEAR, true)).toBe(`1y ago`);
+    expect(timeAgo(new Date().getTime() - YEAR * 2, true)).toBe(`2y ago`);
+});

package/build/utilities/checkVersion.js

@@ -0,0 +1,29 @@
+import semver from 'semver';
+import axios from 'axios';
+import { pkg } from '../pkg.js';
+import { userConfig } from '../userConfig.js';
+import { writeUserConfig } from '../utilities/writeUserConfig.js';
+import { logger } from '../logger.js';
+export const checkVersion = async () => {
+    if (userConfig.newVersion) {
+        if (semver.gt(userConfig.newVersion, pkg.version)) {
+            logger.info(`A new version (${userConfig.newVersion}) of \`mlcl\` is available.`);
+            logger.info(`You are currently on version ${pkg.version}.`);
+        }
+        else {
+            delete userConfig.newVersion;
+            writeUserConfig();
+        }
+    }
+    try {
+        const { version } = (await axios.get(`https://registry.npmjs.org/mlcl/latest`)).data;
+        if (version && semver.gt(version, pkg.version)) {
+            userConfig.newVersion = version;
+            writeUserConfig();
+        }
+    }
+    catch (error) {
+    }
+};
+// Check every time `mlcl` is run.
+checkVersion();

package/build/utilities/getErrorMessage.js

@@ -0,0 +1,15 @@
+/**
+ * Attempts to return a human readable message based on some `Error`.
+ */
+export const getErrorMessage = (error) => {
+    if (!error) {
+        return null;
+    }
+    if (typeof error === `string`) {
+        return error;
+    }
+    return (({ ETIMEDOUT: `Timed out`, ECONNABORTED: `Connection aborted` })[error.code || -1]
+        || error.response?.data?.error
+        || error.message
+        || null);
+};