@michijs/dev-server 0.4.3 → 0.5.0

package/README.md

@@ -1,5 +1,6 @@
 # Michijs Dev Server
 Development server built on top of esbuild.
+<!-- TODO: To generate feature-image require to install roboto -->
 
 ![npm][version] [![license][github-license]][github-license-url] ![npm][npm-downloads] ![npm][repo-size]
   [![CodeQL](https://github.com/michijs/dev-server/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/michijs/dev-server/actions/workflows/codeql-analysis.yml)
@@ -91,14 +92,34 @@ export default config;
       <td colspan="3">If the browser should open at localhost url when server starts</td>
       <td>"true"</td>
     </tr>
+    <tr>
+      <td>watch</td>
+      <td colspan="3">If the server should watch for changes on the folders</td>
+      <td>"true"</td>
+    </tr>
     <tr>
       <td>port</td>
       <td colspan="3">Port to run dev server on</td>
       <td>"3000"</td>
     </tr>
     <tr>
-      <td rowspan="10">public</td>
-      <td rowspan="10">Public folder - will be copied at server start</td>
+      <td rowspan="14">public</td>
+      <td rowspan="14">Public folder - will be copied at server start</td>
+      <tr>
+        <td rowspan="4">assets</td>
+        <tr>
+          <td>path</td>
+          <td>"assets"</td>
+        </tr>
+        <tr>
+          <td>screenshots</td>
+          <td></td>
+        </tr>
+        <tr>
+          <td>featureImage</td>
+          <td></td>
+        </tr>
+      </tr>
       <tr>
         <td colspan="2">indexName</td>
         <td>"index.html"</td>

package/bin/actions/build.js

@@ -1,5 +1,5 @@
-import { config } from '../config/config.js';
-import { build as esbuild } from 'esbuild';
+import { config } from "../config/config.js";
+import { build as esbuild } from "esbuild";
 export function build(callback) {
     return new Promise((resolve, reject) => {
         esbuild(config.esbuildOptions)

package/bin/actions/dist.js

@@ -1,11 +1,11 @@
-import { tsconfig } from '../config/tsconfig.js';
-import { config } from '../config/config.js';
-import { exec } from 'child_process';
-import fs from 'fs';
+import { tsconfig } from "../config/tsconfig.js";
+import { config } from "../config/config.js";
+import { exec } from "child_process";
+import fs from "fs";
 export function dist(callback, watch = false) {
     if (tsconfig.compilerOptions.outDir &&
         fs.existsSync(tsconfig.compilerOptions.outDir)) {
         fs.rmSync(tsconfig.compilerOptions.outDir, { recursive: true });
     }
-    exec(`tsc ${watch ? '-w' : ''} --project ${config.esbuildOptions.tsconfig}`, callback);
+    exec(`tsc ${watch ? "-w" : ""} --project ${config.esbuildOptions.tsconfig}`, callback);
 }

package/bin/actions/generateAssets.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare function generateFeatureImage(src: string): Promise<void>;
+export declare function generateScreenshots(): Promise<(string | Buffer)[][]>;
+export declare function generateAssets(callback: () => void, src: string): Promise<void>;

package/bin/actions/generateAssets.js

@@ -0,0 +1,125 @@
+import { getPath } from "../utils/getPath.js";
+import { config } from "../config/config.js";
+import { mkdirSync, existsSync, writeFileSync, readFileSync, rmSync } from "fs";
+import { pngToIco } from "../utils/pngToIco.js";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+import sharp from "sharp";
+import { getLocalURL } from "../utils/getLocalURL.js";
+import { assetsSizes } from "../constants.js";
+import puppeteer from "puppeteer";
+const generatedPath = getPath(`${config.public.path}/${config.public.assets.path}/generated`);
+const screenshotsPath = getPath(`${generatedPath}/screenshots`);
+const svgPath = resolve(getPath(dirname(fileURLToPath(import.meta.url))), "../..");
+const generateFavicon = async (src, dest) => {
+    const { default: sharp } = await import("sharp");
+    const image = await sharp(src);
+    const iconSizes = [16, 24, 32, 48, 64, 128, 256];
+    const resizedBuffers = await Promise.all(iconSizes.map((size) => {
+        return image.resize(size, size).png().toBuffer();
+    }));
+    writeFileSync(dest, await pngToIco(resizedBuffers, iconSizes));
+};
+config.watch = false;
+config.openBrowser = false;
+const browser = await puppeteer.launch({
+    dumpio: true,
+    headless: "new",
+    product: "chrome",
+});
+const port = await new Promise(async (resolve) => {
+    const { start } = await import("./start.js");
+    start((port) => resolve(port));
+});
+async function takeScreenshots({ viewports, options, pageCallback, path, }) {
+    return await Promise.all(viewports.map(async (viewport) => {
+        // Create a new page
+        const page = await browser.newPage();
+        await page.goto(`${getLocalURL(port)}${path}`);
+        await page.setViewport(viewport);
+        const prefix = await pageCallback?.(page);
+        const screenshot = await page.screenshot({
+            fullPage: true,
+            ...options?.(viewport, prefix ? `_${prefix}` : prefix),
+        });
+        await page.close();
+        return screenshot;
+    }));
+}
+export async function generateFeatureImage(src) {
+    const svgFilePath = getPath(`${svgPath}/feature-image-template.svg`);
+    const [screenshots, icon] = await Promise.all([
+        takeScreenshots({
+            viewports: [
+                // Phone
+                { width: 288, height: 387 },
+                // Tablet
+                { width: 390, height: 280 },
+                // Desktop
+                { width: 900, height: 550 },
+            ],
+            path: config.public.assets.featureImage.path,
+            pageCallback: config.public.assets.featureImage.pageCallback,
+        }),
+        sharp(src).resize(512, 512).png().toBuffer(),
+    ]);
+    const svg = readFileSync(svgFilePath);
+    const svgString = svg
+        .toString()
+        .replace("{{phone-href}}", `data:image/png;base64,${screenshots[0].toString("base64")}`)
+        .replace("{{tablet-href}}", `data:image/png;base64,${screenshots[1].toString("base64")}`)
+        .replace("{{pc-href}}", `data:image/png;base64,${screenshots[2].toString("base64")}`)
+        .replace("{{icon-href}}", `data:image/png;base64,${icon.toString("base64")}`)
+        .replace("{{background}}", config.public.manifest?.options?.background_color ?? "transparent")
+        .replace("{{app-title}}", config.public.manifest?.options?.name ?? "");
+    writeFileSync(getPath(`${generatedPath}/feature-image.svg`), svgString);
+    await sharp(Buffer.from(svgString))
+        .resize(1024, 500)
+        .png()
+        .toFile(getPath(`${generatedPath}/feature-image.png`));
+}
+export async function generateScreenshots() {
+    return await Promise.all(config.public.assets.screenshots.paths.flatMap((path) => config.public.assets.screenshots.pageCallbacks.map(async (pageCallback, index) => await takeScreenshots({
+        viewports: assetsSizes.screenshots,
+        path,
+        pageCallback,
+        options(viewport, pagePrefix = config.public.assets.screenshots.pageCallbacks
+            .length > 1
+            ? `_${index}`
+            : "") {
+            const screenshotPath = getPath(`${screenshotsPath}${pagePrefix}${path.replace("?", "_")}`);
+            if (!existsSync(screenshotPath))
+                mkdirSync(screenshotPath, { recursive: true });
+            return {
+                path: getPath(`${screenshotPath}/screenshot-${viewport.width}x${viewport.height}.png`),
+            };
+        },
+    }))));
+}
+export async function generateAssets(callback, src) {
+    rmSync(generatedPath, { recursive: true });
+    if (!existsSync(generatedPath))
+        mkdirSync(screenshotsPath, { recursive: true });
+    const image = sharp(src);
+    const fileNameWithoutExtension = src.split("/").at(-1)?.split(".")[0];
+    await Promise.all([
+        ...assetsSizes.webp.map((x) => {
+            return image
+                .resize(x, x)
+                .webp()
+                .toFile(getPath(`${generatedPath}/${fileNameWithoutExtension}-${x}.webp`));
+        }),
+        ...assetsSizes.png.map((x) => {
+            return image
+                .resize(x, x)
+                .png()
+                .toFile(getPath(`${generatedPath}/${fileNameWithoutExtension}-${x}.png`));
+        }),
+        generateFavicon(src, getPath(`${config.public.path}/favicon.ico`)),
+        generateFeatureImage(src),
+        generateScreenshots(),
+    ]);
+    callback();
+    await browser.close();
+    process.exit();
+}

package/bin/actions/start.d.ts

@@ -1 +1 @@
-export declare const start: (callback: () => void) => void;
+export declare const start: (callback: (selectedPort: number) => void) => void;

package/bin/actions/start.js

@@ -1,21 +1,23 @@
-import http from 'http';
-import fs from 'fs';
-import { config, hostURL, localURL, connections } from '../config/config.js';
-import coloredString from '../utils/coloredString.js';
-import { getPath } from '../utils/getPath.js';
-import open from 'open';
-import { context } from 'esbuild';
-import watch from 'node-watch';
-import { copyFile } from '../utils/copy.js';
-import { sep } from 'path';
-import { transformers } from '../utils/transformers.js';
+import http from "http";
+import fs from "fs";
+import { config, connections } from "../config/config.js";
+import coloredString from "../utils/coloredString.js";
+import { getPath } from "../utils/getPath.js";
+import open from "open";
+import { context } from "esbuild";
+import watch from "node-watch";
+import { copyFile } from "../utils/copy.js";
+import { sep } from "path";
+import { transformers } from "../utils/transformers.js";
+import { getHostURL } from "../utils/getHostURL.js";
+import { getLocalURL } from "../utils/getLocalURL.js";
 export const start = (callback) => {
     config.esbuildOptions.plugins?.push({
-        name: 'michijs-dev-server-watch-public-folder',
+        name: "michijs-dev-server-watch-public-folder",
         setup(build) {
-            if (config.public.path)
+            if (config.public.path && config.watch)
                 watch.default(config.public.path, {
-                    encoding: 'utf-8',
+                    encoding: "utf-8",
                     persistent: true,
                     recursive: true,
                 }, (event, fileChangedPath) => {
@@ -29,7 +31,7 @@ export const start = (callback) => {
                     fs.rmSync(getPath(`${outDir}/${transformers
                         .find((x) => x.fileRegex.test(fileName))
                         ?.pathTransformer?.(fileName) ?? fileName}`), { force: true, recursive: true });
-                    if (event === 'remove')
+                    if (event === "remove")
                         removed.push(fileChangedPath);
                     else {
                         updated.push(fileChangedPath);
@@ -48,9 +50,8 @@ export const start = (callback) => {
         const { host: esbuildHost, port: esbuildPort } = await buildContext.serve({
             servedir: config.esbuildOptions.outdir,
         });
-        http
-            .createServer(async (req, res) => {
-            if (req.url === '/esbuild')
+        const server = http.createServer(async (req, res) => {
+            if (req.url === "/esbuild")
                 connections.push(res);
             const esbuildProxyRequestOptions = {
                 hostname: esbuildHost,
@@ -63,7 +64,7 @@ export const start = (callback) => {
             const proxyReq = http.request(esbuildProxyRequestOptions, (proxyRes) => {
                 // If esbuild returns "not found", send a custom 404 page
                 if (!proxyRes.statusCode || proxyRes.statusCode === 404) {
-                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.writeHead(200, { "Content-Type": "text/html" });
                     // TODO: Find a better way to do this
                     res.end(fs.readFileSync(getPath(`${config.esbuildOptions.outdir}/${config.public.indexName}`)));
                     return;
@@ -74,16 +75,31 @@ export const start = (callback) => {
             });
             // Forward the body of the request to esbuild
             req.pipe(proxyReq, { end: true });
-        })
-            .listen(config.port);
-        console.log(`
-  Server running at:
-  
-  > Network:  ${coloredString(hostURL)}
-  > Local:    ${coloredString(localURL)}`);
-        callback();
-        buildContext.watch();
-        if (config.openBrowser)
-            open(localURL);
+        });
+        let selectedPort = config.port;
+        server.on("error", (e) => {
+            // @ts-ignore
+            if (e.code === "EADDRINUSE") {
+                selectedPort++;
+                server.listen(selectedPort);
+            }
+            else
+                throw e;
+        });
+        server.on("listening", () => {
+            const localURL = getLocalURL(selectedPort);
+            console.log(`
+    Server running at:
+    
+    > Network:  ${coloredString(getHostURL(selectedPort))}
+    > Local:    ${coloredString(localURL)}`);
+            callback(selectedPort);
+            if (config.watch)
+                buildContext.watch();
+            if (config.openBrowser)
+                open(localURL);
+        });
+        // First try
+        server.listen(selectedPort);
     });
 };

package/bin/cli.js

@@ -1,65 +1,65 @@
-import coloredString from './utils/coloredString.js';
-import yargs from 'yargs';
-import { Timer } from './classes/Timer.js';
-import { hideBin } from 'yargs/helpers';
+import coloredString from "./utils/coloredString.js";
+import yargs from "yargs";
+import { Timer } from "./classes/Timer.js";
+import { hideBin } from "yargs/helpers";
 export async function cli() {
     const timer = new Timer();
-    const showReadyMessage = () => console.log(`
+    const showReadyMessage = () => console.log(`
   ${coloredString(`Ready in ${timer.endTimer()}ms.`)}`);
     timer.startTimer();
     const args = await yargs(hideBin(process.argv))
-        .option('start', {
-        type: 'boolean',
+        .option("start", {
+        type: "boolean",
         default: false,
-        description: 'Allows to start a dev server as a webpage.',
+        description: "Allows to start a dev server as a webpage.",
     })
-        .option('build', {
-        type: 'boolean',
+        .option("build", {
+        type: "boolean",
         default: false,
-        description: 'Allows to build the src code as a webpage.',
+        description: "Allows to build the src code as a webpage.",
     })
-        .option('dist', {
-        type: 'boolean',
+        .option("dist", {
+        type: "boolean",
         default: false,
-        description: 'Allows to distribute the src code as a package.',
+        description: "Allows to distribute the src code as a package.",
     })
-        .option('generate-icons', {
-        type: 'string',
-        description: 'Allows to generate a full set of icons from a src icon.',
+        .option("generate-assets", {
+        type: "string",
+        description: "Allows to generate a full set of icons and screenshots from a src icon.",
     })
-        .option('watch', {
-        type: 'boolean',
+        .option("watch", {
+        type: "boolean",
         default: false,
-        alias: 'w',
+        alias: "w",
     })
-        .option('env', {
-        type: 'string',
+        .option("env", {
+        type: "string",
     })
-        .option('env', {
-        type: 'string',
+        .option("env", {
+        type: "string",
     })
         .help()
-        .alias('help', 'h').argv;
+        .alias("help", "h").argv;
     process.env.NODE_ENV =
         args.env ||
-            (args.build ? 'PRODUCTION' : args.dist ? 'DISTRIBUTION' : 'DEVELOPMENT');
-    const generateIcons = args.generateIcons === '' ? 'public/assets/icon.svg' : args.generateIcons;
-    if (generateIcons) {
-        const action = await import('./actions/generateIcons.js');
-        await action.generateIcons(showReadyMessage, generateIcons);
+            (args.build ? "PRODUCTION" : args.dist ? "DISTRIBUTION" : "DEVELOPMENT");
+    const generateAssets = args.generateAssets === "" ? "public/assets/icon.svg" : args.generateAssets;
+    if (generateAssets) {
+        const action = await import("./actions/generateAssets.js");
+        await action.generateAssets(showReadyMessage, generateAssets);
     }
     else
         console.log(coloredString(`  Running in ${process.env.NODE_ENV} mode`));
     if (args.start) {
-        const action = await import('./actions/start.js');
+        const action = await import("./actions/start.js");
         action.start(showReadyMessage);
     }
     if (args.build) {
-        const action = await import('./actions/build.js');
+        const action = await import("./actions/build.js");
         action.build(showReadyMessage);
     }
     if (args.dist) {
-        const action = await import('./actions/dist.js');
+        const action = await import("./actions/dist.js");
         action.dist(showReadyMessage, args.watch);
     }
 }

package/bin/config/config.d.ts

@@ -1,10 +1,115 @@
 /// <reference types="node" resolution-mode="require"/>
-import { Config } from '../types.js';
-import http from 'http';
+import http from "http";
 export declare const connections: (http.ServerResponse<http.IncomingMessage> & {
     req: http.IncomingMessage;
 })[];
-declare const config: Required<Config>;
-declare const hostURL: string;
-declare const localURL: string;
-export { config, hostURL, localURL };
+declare const config: {
+    public: {
+        assets: {
+            screenshots: {
+                paths: string[];
+                pageCallbacks: import("../types.js").PageCallback<string | void>[];
+            };
+            featureImage: {
+                path: string;
+                pageCallback?: import("../types.js").PageCallback<void> | undefined;
+            };
+            path: string;
+        };
+        manifest: {
+            name: string;
+            options?: import("web-app-manifest").WebAppManifest | undefined;
+        };
+        wellKnown?: import("../types.js").WellKnown[] | undefined;
+        path: string;
+        indexName: string;
+        minify: boolean;
+    };
+    esbuildOptions: {
+        plugins: import("esbuild").Plugin[];
+        define: {
+            michiProcess: string;
+        };
+        inject: string[];
+        bundle: boolean;
+        splitting: boolean;
+        preserveSymlinks?: boolean | undefined;
+        outfile?: string | undefined;
+        metafile?: boolean | undefined;
+        outdir: string;
+        outbase?: string | undefined;
+        external?: string[] | undefined;
+        packages?: "external" | undefined;
+        alias?: Record<string, string> | undefined;
+        loader?: {
+            [ext: string]: import("esbuild").Loader;
+        } | undefined;
+        resolveExtensions?: string[] | undefined;
+        mainFields?: string[] | undefined;
+        conditions?: string[] | undefined;
+        write?: boolean | undefined;
+        allowOverwrite?: boolean | undefined;
+        tsconfig: string;
+        outExtension?: {
+            [ext: string]: string;
+        } | undefined;
+        publicPath?: string | undefined;
+        entryNames?: string | undefined;
+        chunkNames?: string | undefined;
+        assetNames?: string | undefined;
+        banner?: {
+            [type: string]: string;
+        } | undefined;
+        footer?: {
+            [type: string]: string;
+        } | undefined;
+        entryPoints: string[] | Record<string, string> | {
+            in: string;
+            out: string;
+        }[];
+        stdin?: import("esbuild").StdinOptions | undefined;
+        absWorkingDir?: string | undefined;
+        nodePaths?: string[] | undefined;
+        sourcemap: boolean | "linked" | "inline" | "external" | "both";
+        legalComments?: "linked" | "inline" | "external" | "none" | "eof" | undefined;
+        sourceRoot?: string | undefined;
+        sourcesContent?: boolean | undefined;
+        format: import("esbuild").Format;
+        globalName?: string | undefined;
+        target: string | string[];
+        supported?: Record<string, boolean> | undefined;
+        platform?: import("esbuild").Platform | undefined;
+        mangleProps?: RegExp | undefined;
+        reserveProps?: RegExp | undefined;
+        mangleQuoted?: boolean | undefined;
+        mangleCache?: Record<string, string | false> | undefined;
+        drop?: import("esbuild").Drop[] | undefined;
+        minify?: boolean | undefined;
+        minifyWhitespace: boolean;
+        minifyIdentifiers?: boolean | undefined;
+        minifySyntax: boolean;
+        charset?: import("esbuild").Charset | undefined;
+        treeShaking?: boolean | undefined;
+        ignoreAnnotations?: boolean | undefined;
+        jsx?: "transform" | "preserve" | "automatic" | undefined;
+        jsxFactory?: string | undefined;
+        jsxFragment?: string | undefined;
+        jsxImportSource?: string | undefined;
+        jsxDev?: boolean | undefined;
+        jsxSideEffects?: boolean | undefined;
+        pure?: string[] | undefined;
+        keepNames: boolean;
+        color?: boolean | undefined;
+        logLevel: import("esbuild").LogLevel;
+        logLimit?: number | undefined;
+        logOverride?: Record<string, import("esbuild").LogLevel> | undefined;
+    };
+    env?: {
+        [key: string]: any;
+    } | undefined;
+    watch: boolean;
+    port: number;
+    openBrowser: boolean;
+    showLinkedPackages: boolean;
+};
+export { config };

package/bin/config/config.js

@@ -1,48 +1,61 @@
-import fs from 'fs';
-import coloredString from '../utils/coloredString.js';
-import { copy } from '../utils/copy.js';
-import { getPath } from '../utils/getPath.js';
-import { Timer } from '../classes/Timer.js';
-import { getIPAddress } from './getIPAddress.js';
-import { userConfig } from './userConfig.js';
-import { resolve } from 'path';
-import { jsAndTsRegex, jsonTransformer, notJsAndTsRegex, } from '../utils/transformers.js';
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-const minify = process.env.NODE_ENV === 'PRODUCTION';
-const devServerListener = process.env.NODE_ENV === 'DEVELOPMENT'
+import fs from "fs";
+import coloredString from "../utils/coloredString.js";
+import { copy } from "../utils/copy.js";
+import { getPath } from "../utils/getPath.js";
+import { Timer } from "../classes/Timer.js";
+import { userConfig } from "./userConfig.js";
+import { resolve } from "path";
+import { jsAndTsRegex, jsonTransformer, notJsAndTsRegex, } from "../utils/transformers.js";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+const minify = process.env.NODE_ENV === "PRODUCTION";
+const devServerListener = process.env.NODE_ENV === "DEVELOPMENT"
     ? [getPath(`${dirname(fileURLToPath(import.meta.url))}/public/client.js`)]
     : [];
 export const connections = [];
 const config = {
     port: 3000,
-    openBrowser: process.env.NODE_ENV === 'DEVELOPMENT',
+    openBrowser: process.env.NODE_ENV === "DEVELOPMENT",
     showLinkedPackages: true,
+    watch: true,
     ...userConfig,
     // protocol: 'http',
     public: {
-        path: 'public',
-        indexName: 'index.html',
+        path: "public",
+        indexName: "index.html",
         minify: minify,
         ...(userConfig.public ?? {}),
+        assets: {
+            path: "assets",
+            ...(userConfig.public?.assets ?? {}),
+            screenshots: {
+                paths: ["/"],
+                pageCallbacks: [() => { }],
+                ...(userConfig.public?.assets?.screenshots ?? {}),
+            },
+            featureImage: {
+                path: "/",
+                ...(userConfig.public?.assets?.featureImage ?? {}),
+            },
+        },
         manifest: {
-            name: 'manifest.json',
+            name: "manifest.json",
             ...(userConfig.public?.manifest ?? {}),
         },
     },
     esbuildOptions: {
-        outdir: 'build',
-        tsconfig: 'tsconfig.json',
+        outdir: "build",
+        tsconfig: "tsconfig.json",
         minifySyntax: minify,
         minifyWhitespace: minify,
-        sourcemap: process.env.NODE_ENV !== 'PRODUCTION',
+        sourcemap: process.env.NODE_ENV !== "PRODUCTION",
         splitting: true,
         bundle: true,
         keepNames: minify,
-        entryPoints: ['src/index.ts'],
-        format: 'esm',
-        target: 'esnext',
-        logLevel: 'error',
+        entryPoints: ["src/index.ts"],
+        format: "esm",
+        target: "esnext",
+        logLevel: "error",
         ...(userConfig.esbuildOptions ?? {}),
         // Still not supported
         // bug .css.ts
@@ -68,7 +81,7 @@ const config = {
         plugins: [
             ...(userConfig.esbuildOptions?.plugins ?? []),
             {
-                name: 'michijs-dev-server',
+                name: "michijs-dev-server",
                 setup(build) {
                     // Clean outdir
                     if (build.initialOptions.outdir) {
@@ -124,10 +137,6 @@ const config = {
         ...(userConfig.esbuildOptions?.define ?? {}),
     },
 };
-const hostURL = `http://${getIPAddress()}:${config.port}`;
-const localURL = `http://localhost:${config.port}`;
-// const hostURL = `${config.protocol}://${config.hostname}:${config.port}`;
-// const localURL = `${config.protocol}://localhost:${config.port}`;
 function findSymbolickLinkRealPath(packagePath) {
     if (fs.lstatSync(packagePath).isSymbolicLink()) {
         // Getting absolute path for the simbolic link
@@ -136,7 +145,7 @@ function findSymbolickLinkRealPath(packagePath) {
     return packagePath;
 }
 if (config.showLinkedPackages) {
-    const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
     const dependencies = Object.keys(packageJson.dependencies || {});
     const devDependencies = Object.keys(packageJson.devDependencies || {});
     dependencies.concat(devDependencies).forEach((packagePath) => {
@@ -147,4 +156,4 @@ if (config.showLinkedPackages) {
         }
     });
 }
-export { config, hostURL, localURL };
+export { config };