@eik/cli 3.1.3 → 3.1.5

package/classes/publish/package/tasks/create-zip-file.js

@@ -1,78 +1,73 @@
-import fs from 'fs';
-import { join, resolve, basename, dirname } from 'path';
-import * as tar from 'tar';
-import Task from './task.js';
+import fs from "fs";
+import { join, resolve, basename, dirname } from "path";
+import * as tar from "tar";
+import Task from "./task.js";
 
 const { copyFileSync, writeFileSync } = fs;
 
 export default class CreateZipFile extends Task {
-    async process() {
-        const { log, path } = this;
-        const { name, map, server, out, files } = this.config;
+	async process() {
+		const { log, path } = this;
+		const { name, map, server, out, files } = this.config;
 
-        log.debug('Creating zip file');
-        log.debug(`  ==> ${join(path, 'eik.tgz')}`);
+		log.debug("Creating zip file");
+		log.debug(`  ==> ${join(path, "eik.tgz")}`);
 
-        const filesToZip = [];
+		const filesToZip = [];
 
-        try {
-            const eikPathDest = join(path, 'eik.json');
-            writeFileSync(
-                eikPathDest,
-                JSON.stringify(
-                    {
-                        name,
-                        server,
-                        files,
-                        'import-map': map,
-                        out,
-                    },
-                    null,
-                    2,
-                ),
-            );
-            filesToZip.push(basename(eikPathDest));
-        } catch (err) {
-            throw new Error(`Failed to zip eik.json file: ${err.message}`);
-        }
+		try {
+			const eikPathDest = join(path, "eik.json");
+			writeFileSync(
+				eikPathDest,
+				JSON.stringify(
+					{
+						name,
+						server,
+						files,
+						"import-map": map,
+						out,
+					},
+					null,
+					2,
+				),
+			);
+			filesToZip.push(basename(eikPathDest));
+		} catch (err) {
+			throw new Error(`Failed to zip eik.json file: ${err.message}`);
+		}
 
-        if (files) {
-            try {
-                const mappings = await this.config.mappings();
+		if (files) {
+			try {
+				const mappings = await this.config.mappings();
 
-                for (const mapping of mappings) {
-                    const destination = join(
-                        path,
-                        mapping.destination.filePathname,
-                    );
-                    await fs.promises.mkdir(dirname(destination), {
-                        recursive: true,
-                    });
-                    copyFileSync(mapping.source.absolute, destination);
-                    filesToZip.push(destination.replace(path, '.'));
-                }
-            } catch (err) {
-                throw new Error(
-                    `Failed to copy files for zipping: ${err.message}`,
-                );
-            }
-        }
+				for (const mapping of mappings) {
+					const destination = join(path, mapping.destination.filePathname);
+					await fs.promises.mkdir(dirname(destination), {
+						recursive: true,
+					});
+					copyFileSync(mapping.source.absolute, destination);
+					filesToZip.push(destination.replace(path, "."));
+				}
+			} catch (err) {
+				throw new Error(`Failed to copy files for zipping: ${err.message}`);
+			}
+		}
 
-        try {
-            const zipFile = resolve(path, 'eik.tgz');
+		try {
+			const zipFile = resolve(path, "eik.tgz");
 
-            await tar.c(
-                {
-                    gzip: true,
-                    file: zipFile,
-                    cwd: path,
-                },
-                filesToZip,
-            );
+			await tar.c(
+				{
+					gzip: true,
+					file: zipFile,
+					cwd: path,
+				},
+				filesToZip,
+			);
 
-            return zipFile;
-        } catch (err) {
-            throw new Error(`Unable to create zip file: ${err.message}`);
-        }
-    }
+			return zipFile;
+		} catch (err) {
+			throw new Error(`Unable to create zip file: ${err.message}`);
+		}
+	}
 }

package/classes/publish/package/tasks/dry-run.js

@@ -1,22 +1,22 @@
-import { join } from 'path';
-import Task from './task.js';
+import { join } from "path";
+import Task from "./task.js";
 
 export default class DryRun extends Task {
-    async process(zipFile) {
-        const { path } = this;
+	async process(zipFile) {
+		const { path } = this;
 
-        const files = [
-            { pathname: path, type: 'temporary directory' },
-            { pathname: zipFile, type: 'package archive' },
-        ];
+		const files = [
+			{ pathname: path, type: "temporary directory" },
+			{ pathname: zipFile, type: "package archive" },
+		];
 
-        const mappings = await this.config.mappings();
+		const mappings = await this.config.mappings();
 
-        for (const mapping of mappings) {
-            const destination = join(path, mapping.destination.filePathname);
-            files.push({ pathname: destination, type: 'package file' });
-        }
+		for (const mapping of mappings) {
+			const destination = join(path, mapping.destination.filePathname);
+			files.push({ pathname: destination, type: "package file" });
+		}
 
-        return files;
-    }
+		return files;
+	}
 }

package/classes/publish/package/tasks/save-metafile.js

@@ -1,20 +1,20 @@
-import { join } from 'path';
-import json from '../../../../utils/json/index.js';
-import Task from './task.js';
+import { join } from "path";
+import json from "../../../../utils/json/index.js";
+import Task from "./task.js";
 
 export default class SaveMetaFile extends Task {
-    async process(response) {
-        const { log, cwd } = this;
-        const { out } = this.config;
-        const filepath = join(out, 'integrity.json');
-        log.debug('Saving integrity file');
-        log.debug(`  ==> ${filepath}`);
-        try {
-            await json.write(response, { cwd, filename: filepath });
-        } catch (err) {
-            throw new Error(
-                `Unable to save integrity file [${filepath}]: ${err.message}`,
-            );
-        }
-    }
+	async process(response) {
+		const { log, cwd } = this;
+		const { out } = this.config;
+		const filepath = join(out, "integrity.json");
+		log.debug("Saving integrity file");
+		log.debug(`  ==> ${filepath}`);
+		try {
+			await json.write(response, { cwd, filename: filepath });
+		} catch (err) {
+			throw new Error(
+				`Unable to save integrity file [${filepath}]: ${err.message}`,
+			);
+		}
+	}
 }

package/classes/publish/package/tasks/task.js

@@ -1,10 +1,10 @@
-import abslog from 'abslog';
+import abslog from "abslog";
 
 export default class Task {
-    constructor(options) {
-        this.cwd = options.cwd;
-        this.log = abslog(options.logger);
-        this.path = options.path;
-        this.config = options.config;
-    }
+	constructor(options) {
+		this.cwd = options.cwd;
+		this.log = abslog(options.logger);
+		this.path = options.path;
+		this.config = options.config;
+	}
 }

package/classes/publish/package/tasks/upload-files.js

@@ -1,62 +1,58 @@
-import { request } from '../../../../utils/http/index.js';
-import { typeSlug } from '../../../../utils/index.js';
-import { joinUrlPathname } from '../../../../utils/url.js';
+import { request } from "../../../../utils/http/index.js";
+import { typeSlug } from "../../../../utils/index.js";
+import { joinUrlPathname } from "../../../../utils/url.js";
 
-import Task from './task.js';
+import Task from "./task.js";
 
 export default class UploadFiles extends Task {
-    async process(zipFile) {
-        const { log } = this;
-        const { server, name, version, type, token } = this.config;
-        log.debug('Uploading zip file to server');
-        try {
-            const pathname = joinUrlPathname(
-                typeSlug(type),
-                encodeURIComponent(name),
-                version,
-            );
+	async process(zipFile) {
+		const { log } = this;
+		const { server, name, version, type, token } = this.config;
+		log.debug("Uploading zip file to server");
+		try {
+			const pathname = joinUrlPathname(
+				typeSlug(type),
+				encodeURIComponent(name),
+				version,
+			);
 
-            const { message } = await request({
-                method: 'PUT',
-                host: server,
-                pathname,
-                file: zipFile,
-                token,
-            });
+			const { message } = await request({
+				method: "PUT",
+				host: server,
+				pathname,
+				file: zipFile,
+				token,
+			});
 
-            return message;
-        } catch (err) {
-            log.error('Unable to upload zip file to server');
-            switch (err.statusCode) {
-                case 400:
-                    throw new Error(
-                        `${err.statusCode}: Client attempted to send an invalid URL parameter`,
-                    );
-                case 401:
-                    throw new Error(
-                        `${err.statusCode}: Client unauthorized with server`,
-                    );
-                case 404:
-                    throw new Error(
-                        `${err.statusCode}: Client could not find server route`,
-                    );
-                case 409:
-                    throw new Error(
-                        `Package with name "${name}" and version "${version}" already exists on server`,
-                    );
-                case 415:
-                    throw new Error(
-                        `${err.statusCode}: Client attempted to send an unsupported file format to server`,
-                    );
-                case 502:
-                    throw new Error(
-                        `${err.statusCode}: Server was unable to write file to storage, ${err.message}`,
-                    );
-                default:
-                    throw new Error(
-                        `${err.statusCode}: Server failed, ${err.message}`,
-                    );
-            }
-        }
-    }
+			return message;
+		} catch (err) {
+			log.error("Unable to upload zip file to server");
+			switch (err.statusCode) {
+				case 400:
+					throw new Error(
+						`${err.statusCode}: Client attempted to send an invalid URL parameter`,
+					);
+				case 401:
+					throw new Error(`${err.statusCode}: Client unauthorized with server`);
+				case 404:
+					throw new Error(
+						`${err.statusCode}: Client could not find server route`,
+					);
+				case 409:
+					throw new Error(
+						`Package with name "${name}" and version "${version}" already exists on server`,
+					);
+				case 415:
+					throw new Error(
+						`${err.statusCode}: Client attempted to send an unsupported file format to server`,
+					);
+				case 502:
+					throw new Error(
+						`${err.statusCode}: Server was unable to write file to storage, ${err.message}`,
+					);
+				default:
+					throw new Error(`${err.statusCode}: Server failed, ${err.message}`);
+			}
+		}
+	}
 }

package/classes/publish/package/tasks/validate-input.js

@@ -1,33 +1,33 @@
-import { parse } from 'path';
-import Task from './task.js';
+import { parse } from "path";
+import Task from "./task.js";
 
 class ValidationError extends Error {
-    constructor(message, err) {
-        let m = message;
-        if (err && err.message) m += `: ${err.message}`;
-        super(m);
-        this.name = this.constructor.name;
-        Error.captureStackTrace(this, this.constructor);
-    }
+	constructor(message, err) {
+		let m = message;
+		if (err && err.message) m += `: ${err.message}`;
+		super(m);
+		this.name = this.constructor.name;
+		Error.captureStackTrace(this, this.constructor);
+	}
 }
 
 export default class ValidateInput extends Task {
-    process() {
-        const { log } = this;
-        const { cwd, dryRun } = this.config;
+	process() {
+		const { log } = this;
+		const { cwd, dryRun } = this.config;
 
-        log.debug('Validating input');
+		log.debug("Validating input");
 
-        try {
-            log.debug(`  ==> cwd: ${cwd}`);
-            parse(cwd);
-        } catch (err) {
-            throw new ValidationError('Parameter "cwd" is not valid', err);
-        }
+		try {
+			log.debug(`  ==> cwd: ${cwd}`);
+			parse(cwd);
+		} catch (err) {
+			throw new ValidationError('Parameter "cwd" is not valid', err);
+		}
 
-        log.debug(`  ==> dryRun: ${dryRun}`);
-        if (dryRun && dryRun !== true && dryRun !== false) {
-            throw new ValidationError('Parameter "dryRun" is not valid');
-        }
-    }
+		log.debug(`  ==> dryRun: ${dryRun}`);
+		if (dryRun && dryRun !== true && dryRun !== false) {
+			throw new ValidationError('Parameter "dryRun" is not valid');
+		}
+	}
 }