@eik/cli 3.1.3 → 3.1.4

package/classes/publish/package/index.js

@@ -1,16 +1,16 @@
-import abslog from 'abslog';
-import { join, isAbsolute } from 'path';
-import { EikConfig } from '@eik/common';
-import { typeSlug } from '../../../utils/index.js';
-import ValidateInput from './tasks/validate-input.js';
-import CreateTempDirectory from './tasks/create-temp-directory.js';
-import CreateZipFile from './tasks/create-zip-file.js';
-import CheckBundleSizes from './tasks/check-bundle-sizes.js';
-import DryRun from './tasks/dry-run.js';
-import CheckIfAlreadyPublished from './tasks/check-if-already-published.js';
-import UploadFiles from './tasks/upload-files.js';
-import SaveMetafile from './tasks/save-metafile.js';
-import Cleanup from './tasks/cleanup.js';
+import abslog from "abslog";
+import { join, isAbsolute } from "path";
+import { EikConfig } from "@eik/common";
+import { typeSlug } from "../../../utils/index.js";
+import ValidateInput from "./tasks/validate-input.js";
+import CreateTempDirectory from "./tasks/create-temp-directory.js";
+import CreateZipFile from "./tasks/create-zip-file.js";
+import CheckBundleSizes from "./tasks/check-bundle-sizes.js";
+import DryRun from "./tasks/dry-run.js";
+import CheckIfAlreadyPublished from "./tasks/check-if-already-published.js";
+import UploadFiles from "./tasks/upload-files.js";
+import SaveMetafile from "./tasks/save-metafile.js";
+import Cleanup from "./tasks/cleanup.js";
 
 /**
  * @typedef {object} PublishOptions
@@ -44,128 +44,128 @@ import Cleanup from './tasks/cleanup.js';
  */
 
 export default class Publish {
-    /**
-     * @param {PublishOptions} options
-     */
-    constructor({
-        logger,
-        cwd = process.cwd(),
-        token,
-        dryRun = false,
-        server,
-        type = 'package',
-        name,
-        version = '1.0.0',
-        map = [],
-        out = './.eik',
-        files = {},
-    }) {
-        const config = new EikConfig(
-            {
-                server,
-                type,
-                name,
-                version,
-                'import-map': map,
-                out,
-                files,
-            },
-            [[server, token]],
-            cwd,
-        );
-        config.validate();
+	/**
+	 * @param {PublishOptions} options
+	 */
+	constructor({
+		logger,
+		cwd = process.cwd(),
+		token,
+		dryRun = false,
+		server,
+		type = "package",
+		name,
+		version = "1.0.0",
+		map = [],
+		out = "./.eik",
+		files = {},
+	}) {
+		const config = new EikConfig(
+			{
+				server,
+				type,
+				name,
+				version,
+				"import-map": map,
+				out,
+				files,
+			},
+			[[server, token]],
+			cwd,
+		);
+		config.validate();
 
-        this.log = abslog(logger);
-        this.cwd = cwd;
-        this.dryRun = dryRun;
-        this.config = config;
-        this.path = isAbsolute(config.out) ? config.out : join(cwd, config.out);
+		this.log = abslog(logger);
+		this.cwd = cwd;
+		this.dryRun = dryRun;
+		this.config = config;
+		this.path = isAbsolute(config.out) ? config.out : join(cwd, config.out);
 
-        this.validateInput = new ValidateInput({
-            logger: this.log,
-            path: this.path,
-            config,
-        });
-        this.createTempDirectory = new CreateTempDirectory({
-            path: this.path,
-            logger: this.log,
-            config,
-        });
-        this.createZipFile = new CreateZipFile({
-            logger: this.log,
-            path: this.path,
-            config,
-        });
-        this.checkBundleSizes = new CheckBundleSizes({
-            cwd,
-            logger: this.log,
-            config,
-        });
-        this.runDryRun = new DryRun({ path: this.path, config });
-        this.checkIfAlreadyPublished = new CheckIfAlreadyPublished({
-            logger: this.log,
-            path: this.path,
-            config,
-        });
-        this.uploadFiles = new UploadFiles({ logger: this.log, config });
-        this.saveMetafile = new SaveMetafile({ logger: this.log, cwd, config });
-        this.cleanup = new Cleanup({
-            logger: this.log,
-            path: this.path,
-            config,
-        });
-    }
+		this.validateInput = new ValidateInput({
+			logger: this.log,
+			path: this.path,
+			config,
+		});
+		this.createTempDirectory = new CreateTempDirectory({
+			path: this.path,
+			logger: this.log,
+			config,
+		});
+		this.createZipFile = new CreateZipFile({
+			logger: this.log,
+			path: this.path,
+			config,
+		});
+		this.checkBundleSizes = new CheckBundleSizes({
+			cwd,
+			logger: this.log,
+			config,
+		});
+		this.runDryRun = new DryRun({ path: this.path, config });
+		this.checkIfAlreadyPublished = new CheckIfAlreadyPublished({
+			logger: this.log,
+			path: this.path,
+			config,
+		});
+		this.uploadFiles = new UploadFiles({ logger: this.log, config });
+		this.saveMetafile = new SaveMetafile({ logger: this.log, cwd, config });
+		this.cleanup = new Cleanup({
+			logger: this.log,
+			path: this.path,
+			config,
+		});
+	}
 
-    /**
-     * @returns {Promise<PublishResult>}
-     */
-    async run() {
-        this.log.debug(`Running package command against server`);
-        this.log.debug(`  ==> package name: ${this.config.name}`);
-        this.log.debug(`  ==> package version: ${this.config.version}`);
-        this.log.debug(`  ==> server: ${this.config.server}`);
-        this.log.debug(`  ==> type: ${this.config.type}`);
+	/**
+	 * @returns {Promise<PublishResult>}
+	 */
+	async run() {
+		this.log.debug(`Running package command against server`);
+		this.log.debug(`  ==> package name: ${this.config.name}`);
+		this.log.debug(`  ==> package version: ${this.config.version}`);
+		this.log.debug(`  ==> server: ${this.config.server}`);
+		this.log.debug(`  ==> type: ${this.config.type}`);
 
-        await this.validateInput.process();
-        await this.createTempDirectory.process();
-        const zipFile = await this.createZipFile.process();
-        await this.checkBundleSizes.process();
+		await this.validateInput.process();
+		await this.createTempDirectory.process();
+		const zipFile = await this.createZipFile.process();
+		await this.checkBundleSizes.process();
 
-        if (this.dryRun) {
-            const files = await this.runDryRun.process(zipFile);
-            return {
-                type: typeSlug(this.config.type),
-                server: this.config.server,
-                name: this.config.name,
-                // @ts-expect-error Not sure where this.level originated
-                level: this.level,
-                dryRun: this.dryRun,
-                integrity: '',
-                created: null,
-                author: {},
-                org: '',
-                version: this.config.version,
-                response: {},
-                files,
-            };
-        }
+		if (this.dryRun) {
+			const files = await this.runDryRun.process(zipFile);
+			return {
+				type: typeSlug(this.config.type),
+				server: this.config.server,
+				name: this.config.name,
+				// @ts-expect-error Not sure where this.level originated
+				level: this.level,
+				dryRun: this.dryRun,
+				integrity: "",
+				created: null,
+				author: {},
+				org: "",
+				version: this.config.version,
+				response: {},
+				files,
+			};
+		}
 
-        const response = await this.uploadFiles.process(zipFile);
-        await this.saveMetafile.process(response);
-        await this.cleanup.process();
+		const response = await this.uploadFiles.process(zipFile);
+		await this.saveMetafile.process(response);
+		await this.cleanup.process();
 
-        return {
-            type: typeSlug(this.config.type),
-            server: this.config.server,
-            name: this.config.name,
-            // @ts-expect-error Not sure where this.level originated
-            level: this.level,
-            dryRun: this.dryRun,
-            created: null,
-            author: {},
-            org: '',
-            version: this.config.version,
-            ...response,
-        };
-    }
+		return {
+			type: typeSlug(this.config.type),
+			server: this.config.server,
+			name: this.config.name,
+			// @ts-expect-error Not sure where this.level originated
+			level: this.level,
+			dryRun: this.dryRun,
+			created: null,
+			author: {},
+			org: "",
+			version: this.config.version,
+			...response,
+		};
+	}
 }

package/classes/publish/package/tasks/check-bundle-sizes.js

@@ -1,24 +1,22 @@
-import bytes from 'bytes';
-import fs from 'fs';
-import { gzipSizeSync } from 'gzip-size';
-import Task from './task.js';
+import bytes from "bytes";
+import fs from "fs";
+import { gzipSizeSync } from "gzip-size";
+import Task from "./task.js";
 
 export default class CheckBundleSizes extends Task {
-    async process() {
-        this.log.debug('Checking bundle file sizes');
-        try {
-            for (const mapping of await this.config.mappings()) {
-                const file = mapping.source.absolute;
-                this.log.debug(
-                    `  ==> entrypoint size (${
-                        mapping.source.destination
-                    } => ${file}): ${bytes(
-                        gzipSizeSync(fs.readFileSync(file, 'utf8')),
-                    )}`,
-                );
-            }
-        } catch (err) {
-            throw new Error(`Failed to check bundle sizes: ${err.message}`);
-        }
-    }
+	async process() {
+		this.log.debug("Checking bundle file sizes");
+		try {
+			for (const mapping of await this.config.mappings()) {
+				const file = mapping.source.absolute;
+				this.log.debug(
+					`  ==> entrypoint size (${
+						mapping.source.destination
+					} => ${file}): ${bytes(gzipSizeSync(fs.readFileSync(file, "utf8")))}`,
+				);
+			}
+		} catch (err) {
+			throw new Error(`Failed to check bundle sizes: ${err.message}`);
+		}
+	}
 }

package/classes/publish/package/tasks/check-if-already-published.js

@@ -1,84 +1,79 @@
-import { join } from 'path';
-import { integrity, versions } from '../../../../utils/http/index.js';
-import hash from '../../../../utils/hash/index.js';
-import { typeSlug } from '../../../../utils/index.js';
-import Task from './task.js';
+import { join } from "path";
+import { integrity, versions } from "../../../../utils/http/index.js";
+import hash from "../../../../utils/hash/index.js";
+import { typeSlug } from "../../../../utils/index.js";
+import Task from "./task.js";
 
 export default class CheckIfAlreadyPublished extends Task {
-    async process() {
-        const { log, path } = this;
-        const { server, name, version, files, type } = this.config;
+	async process() {
+		const { log, path } = this;
+		const { server, name, version, files, type } = this.config;
 
-        log.debug(
-            `Checking for existence of package ${name} version ${version}`,
-        );
-        log.debug('  ==> Fetching package metadata from server');
+		log.debug(`Checking for existence of package ${name} version ${version}`);
+		log.debug("  ==> Fetching package metadata from server");
 
-        try {
-            if (await integrity(server, typeSlug(type), name, version)) {
-                throw new Error(
-                    `${name} version ${version} already exists on the Eik server. Publishing is not necessary.`,
-                );
-            }
-            log.debug(`  ==> Package version ${version} does not yet exist`);
-        } catch (err) {
-            throw new Error(
-                `Unable to fetch package metadata from server: ${err.message}`,
-            );
-        }
+		try {
+			if (await integrity(server, typeSlug(type), name, version)) {
+				throw new Error(
+					`${name} version ${version} already exists on the Eik server. Publishing is not necessary.`,
+				);
+			}
+			log.debug(`  ==> Package version ${version} does not yet exist`);
+		} catch (err) {
+			throw new Error(
+				`Unable to fetch package metadata from server: ${err.message}`,
+			);
+		}
 
-        let pkgVersions;
-        try {
-            pkgVersions = await versions(server, typeSlug(type), name);
-        } catch (err) {
-            throw new Error(
-                `Unable to fetch package metadata from server: ${err.message}`,
-            );
-        }
+		let pkgVersions;
+		try {
+			pkgVersions = await versions(server, typeSlug(type), name);
+		} catch (err) {
+			throw new Error(
+				`Unable to fetch package metadata from server: ${err.message}`,
+			);
+		}
 
-        if (!pkgVersions) {
-            log.debug('  ==> Package has never been published');
-            return null;
-        }
+		if (!pkgVersions) {
+			log.debug("  ==> Package has never been published");
+			return null;
+		}
 
-        log.debug(`  ==> However, previous versions of package do exist`);
-        log.debug('  ==> Checking if local files have changed');
+		log.debug(`  ==> However, previous versions of package do exist`);
+		log.debug("  ==> Checking if local files have changed");
 
-        let localHash;
-        try {
-            const localFiles = [join(path, 'eik.json')];
-            if (files) {
-                const mappings = await this.config.mappings();
+		let localHash;
+		try {
+			const localFiles = [join(path, "eik.json")];
+			if (files) {
+				const mappings = await this.config.mappings();
 
-                for (const mapping of mappings) {
-                    const destination = join(
-                        path,
-                        mapping.destination.filePathname,
-                    );
-                    localFiles.push(destination);
-                }
-            }
-            localHash = await hash.files(localFiles);
-        } catch (err) {
-            throw new Error(
-                `Unable to hash local files for comparison: ${err.message}`,
-            );
-        }
+				for (const mapping of mappings) {
+					const destination = join(path, mapping.destination.filePathname);
+					localFiles.push(destination);
+				}
+			}
+			localHash = await hash.files(localFiles);
+		} catch (err) {
+			throw new Error(
+				`Unable to hash local files for comparison: ${err.message}`,
+			);
+		}
 
-        // @ts-expect-error
-        const versionMap = new Map(pkgVersions);
-        for (const v of versionMap.values()) {
-            const same = hash.compare(v.integrity, localHash);
-            if (same) {
-                throw new Error(
-                    `Version ${v.version} of this package already contains these files, publishing is not necessary.`,
-                );
-            }
-            log.debug(
-                '  ==> New files do not match existing files, continue with publishing',
-            );
-        }
+		// @ts-expect-error
+		const versionMap = new Map(pkgVersions);
+		for (const v of versionMap.values()) {
+			const same = hash.compare(v.integrity, localHash);
+			if (same) {
+				throw new Error(
+					`Version ${v.version} of this package already contains these files, publishing is not necessary.`,
+				);
+			}
+			log.debug(
+				"  ==> New files do not match existing files, continue with publishing",
+			);
+		}
 
-        return localHash;
-    }
+		return localHash;
+	}
 }

package/classes/publish/package/tasks/cleanup.js

@@ -1,21 +1,21 @@
-import { join } from 'node:path';
-import { existsSync } from 'node:fs';
-import { readdir } from 'node:fs/promises';
-import { rimraf } from 'rimraf';
-import Task from './task.js';
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { rimraf } from "rimraf";
+import Task from "./task.js";
 
 export default class Cleanup extends Task {
-    async process() {
-        const { log, path } = this;
-        log.debug('Cleaning up');
+	async process() {
+		const { log, path } = this;
+		log.debug("Cleaning up");
 
-        if (existsSync(path)) {
-            const dir = await readdir(path);
-            await Promise.all(
-                dir
-                    .filter((file) => file !== 'integrity.json')
-                    .map((file) => rimraf(join(path, file))),
-            );
-        }
-    }
+		if (existsSync(path)) {
+			const dir = await readdir(path);
+			await Promise.all(
+				dir
+					.filter((file) => file !== "integrity.json")
+					.map((file) => rimraf(join(path, file))),
+			);
+		}
+	}
 }

package/classes/publish/package/tasks/create-temp-directory.js

@@ -1,25 +1,25 @@
-import { makeDirectorySync } from 'make-dir';
-import Task from './task.js';
+import { makeDirectorySync } from "make-dir";
+import Task from "./task.js";
 
 class IOError extends Error {
-    constructor(message, err) {
-        super(`${message}: ${err.message}`);
-        this.name = this.constructor.name;
-        Error.captureStackTrace(this, this.constructor);
-    }
+	constructor(message, err) {
+		super(`${message}: ${err.message}`);
+		this.name = this.constructor.name;
+		Error.captureStackTrace(this, this.constructor);
+	}
 }
 
 export default class CreateTempDir extends Task {
-    async process() {
-        const { log, path } = this;
+	async process() {
+		const { log, path } = this;
 
-        log.debug(`Creating temporary directory`);
-        log.debug(`  ==> ${path}`);
+		log.debug(`Creating temporary directory`);
+		log.debug(`  ==> ${path}`);
 
-        try {
-            makeDirectorySync(path);
-        } catch (err) {
-            throw new IOError('Unable to create temp dir', err);
-        }
-    }
+		try {
+			makeDirectorySync(path);
+		} catch (err) {
+			throw new IOError("Unable to create temp dir", err);
+		}
+	}
 }