@lexjs/web 2.0.0

package/dist/actions/core-actions.js

@@ -0,0 +1,6 @@
+import { FileTree } from '@lexjs/filetree';
+import { coreActions } from '@lexjs/filetree/actions';
+import { paths } from '../create-app/paths.js';
+import { tree } from '../create-app/tree.js';
+const fileTree = new FileTree(paths.root, tree);
+export const useCoreActions = fileTree.use(coreActions);

package/dist/actions/npm-actions.js

@@ -0,0 +1,38 @@
+import { FileTree } from '@lexjs/filetree';
+import { $, ExecaError } from 'execa';
+import { logger } from '../utils/logger.js';
+export const npmCommands = {
+    install: 'install',
+    link: 'link',
+};
+const dirActions = FileTree.dirActions((targetDir) => ({
+    async [npmCommands.install](deps) {
+        const currentDir = process.cwd();
+        process.chdir(targetDir.path);
+        try {
+            await $ `npm install ${deps.join(' ')}`;
+        }
+        catch (error) {
+            if (error instanceof Error || error instanceof ExecaError) {
+                logger.error(error.message);
+            }
+        }
+        process.chdir(currentDir);
+    },
+    async [npmCommands.link](deps) {
+        const currentDir = process.cwd();
+        process.chdir(targetDir.path);
+        try {
+            await Promise.all(deps.map((dependency) => $ `npm link ${dependency}`));
+        }
+        catch (error) {
+            if (error instanceof Error || error instanceof ExecaError) {
+                logger.error(error.message);
+            }
+        }
+        process.chdir(currentDir);
+    },
+}));
+export const npmActions = {
+    dir: dirActions,
+};

package/dist/actions/permission-actions.js

@@ -0,0 +1,21 @@
+import { FileTree } from '@lexjs/filetree';
+import { $, ExecaError } from 'execa';
+import { logger } from '../utils/logger.js';
+const dirActions = FileTree.dirActions((targetDir) => ({
+    async x(fileName) {
+        const currentPath = process.cwd();
+        process.chdir(targetDir.path);
+        try {
+            await $ `chmod +x ${fileName}`;
+        }
+        catch (error) {
+            if (error instanceof Error || error instanceof ExecaError) {
+                logger.error(error.message);
+            }
+        }
+        process.chdir(currentPath);
+    },
+}));
+export const permissionActions = {
+    dir: dirActions,
+};

package/dist/api/browser/browser.js

@@ -0,0 +1,111 @@
+import open, { apps, openApp } from 'open';
+import { returnTypeGuard } from '../utils/return-type-guard.js';
+export class Browser {
+    #browserName;
+    #config;
+    constructor(browserName, config) {
+        this.#browserName = browserName;
+        this.#config = config;
+    }
+    async open(url, options = {}) {
+        const urls = this.getUrls(url);
+        if (this.#browserName == null) {
+            if (urls.length > 0) {
+                await Promise.all(urls.map(async (link) => {
+                    await open(link);
+                }));
+            }
+            return;
+        }
+        const browserAppName = this.getBrowserAppName(this.#browserName);
+        if (urls.length > 0) {
+            await Promise.all(urls.map(async (link) => {
+                await this.handleOpen(async (browserArguments) => {
+                    await open(link, {
+                        app: {
+                            name: browserAppName,
+                            arguments: browserArguments,
+                        },
+                    });
+                }, options);
+            }));
+            return;
+        }
+        this.handleOpen(async (browserArguments) => {
+            await openApp(browserAppName, {
+                arguments: browserArguments,
+            });
+        }, options);
+    }
+    async handleOpen(handler, options) {
+        const { profile: profileValue, incognito = false } = options;
+        const profiles = this.getProfiles(profileValue);
+        if (profiles.length > 0) {
+            await Promise.all(profiles.map(async (profile) => {
+                const browserArguments = this.getBrowserArguments(incognito, profile);
+                await handler(browserArguments);
+            }));
+            return;
+        }
+        await handler(this.getBrowserArguments(incognito));
+    }
+    getUrls(value) {
+        if (typeof value === 'string') {
+            return [value];
+        }
+        if (Array.isArray(value) &&
+            value.every((url) => typeof url === 'string')) {
+            return value;
+        }
+        return [];
+    }
+    getProfiles(profileValue) {
+        if (typeof profileValue === 'string') {
+            return [profileValue];
+        }
+        if (Array.isArray(profileValue) &&
+            profileValue.every((value) => typeof value === 'string')) {
+            return profileValue;
+        }
+        const { profiles } = this.#config ?? {};
+        if (profileValue != null &&
+            profileValue instanceof Function &&
+            profiles != null) {
+            const result = returnTypeGuard(profileValue, profiles);
+            if (result != null) {
+                return Array.isArray(result) ? result : [result];
+            }
+        }
+        return [];
+    }
+    getBrowserAppName(browserName) {
+        switch (browserName.toLowerCase()) {
+            case 'chrome':
+                return apps.chrome;
+            case 'firefox':
+                return apps.firefox;
+            case 'edge':
+                return apps.edge;
+            default:
+                return browserName;
+        }
+    }
+    getBrowserArguments(incognito, profileDirectory) {
+        const browserName = this.#browserName;
+        const browserArguments = [];
+        if (profileDirectory != null) {
+            browserArguments.push(`--profile-directory=${profileDirectory}`);
+        }
+        if (browserName != null && incognito) {
+            let incognitoValue = 'incognito';
+            if (browserName === 'edge') {
+                incognitoValue = 'inprivate';
+            }
+            else if (browserName === 'firefox' || browserName === 'opera') {
+                incognitoValue = 'private';
+            }
+            browserArguments.push(`--${incognitoValue}`);
+        }
+        return browserArguments;
+    }
+}

package/dist/api/browser/browser.types.js

@@ -0,0 +1 @@
+export {};

package/dist/api/matchers/matchers.js

@@ -0,0 +1,9 @@
+export const matchers = {
+    url: /^(https?:\/\/)?(\b([A-Za-z0-9]+([A-Za-z0-9-])*([A-Za-z0-9])*\b)\.)+[a-z]{2,}\/?/i,
+    port: /:(\d{1,5})/,
+    protocol: /^https?:\/\//,
+    slash: {
+        leading: /^\//,
+        trailing: /\/$/,
+    },
+};

package/dist/api/site/site.js

@@ -0,0 +1,248 @@
+import { matchers } from '../matchers/matchers.js';
+import { extractProtocol } from '../utils/extract-protocol.js';
+import { removeProtocol } from '../utils/remove-protocol.js';
+import { returnTypeGuard } from '../utils/return-type-guard.js';
+import { slash } from '../utils/slash.js';
+export class Site {
+    #baseUrl;
+    #config;
+    #delimiter = ' ';
+    constructor(baseUrl, config = {}) {
+        this.#baseUrl = baseUrl;
+        this.#config = config;
+        if (config.delimiter != null) {
+            this.#delimiter = config.delimiter;
+        }
+    }
+    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+    /*                 PUBLIC API               */
+    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+    /**
+     * Creates base URLs with a protocol and a port, if provided
+     */
+    getBaseUrls(options = {}) {
+        const { port: portValue, unsecureHttp } = options;
+        const emptyPortsArray = Array.isArray(portValue) && portValue.length === 0;
+        if (portValue == null || emptyPortsArray) {
+            const baseUrl = this.getUrlWithProtocol(this.#baseUrl, unsecureHttp);
+            return [this.getHref(baseUrl)];
+        }
+        const ports = this.getUniquePorts(portValue);
+        return (ports
+            // add ports
+            .reduce((result, port) => [
+            ...result,
+            ...this.getUrlWithPort(this.#baseUrl, port).filter((url) => !result.includes(url)),
+        ], [])
+            // add protocol
+            .map((url) => this.getUrlWithProtocol(url, unsecureHttp))
+            .map((url) => this.getHref(url)));
+    }
+    /**
+     * Creates search URLs.
+     *
+     * - If search value is not provided or is empty,
+     * then URLs are created by using the base URL
+     */
+    search(searchValue, options = {}) {
+        const { queryPath, port, split, unsecureHttp } = options;
+        return searchValue == null || searchValue.trim() === ''
+            ? this.getBaseUrls({ port, unsecureHttp })
+            : this.getSearchUrls(searchValue, {
+                queryPath,
+                port,
+                split,
+                unsecureHttp,
+            });
+    }
+    /**
+     * Creates URLs for the provided resource
+     */
+    resource(resourceValue, options = {}) {
+        const { path: pathValue, port, unsecureHttp } = options;
+        const baseUrls = this.getBaseUrls({ port, unsecureHttp });
+        const resources = this.getResourceValues(resourceValue);
+        const paths = this.getResourceValues(pathValue);
+        const resourceUrls = baseUrls.reduce((result, baseUrl) => [
+            ...result,
+            ...resources
+                .map((resource) => slash.trailing.add(baseUrl) + slash.leading.remove(resource))
+                .filter((url) => !result.includes(url)),
+        ], []);
+        if (paths.length > 0) {
+            return resourceUrls.reduce((result, url) => [
+                ...result,
+                ...paths.map((path) => (path.startsWith('?') ? url : slash.trailing.add(url)) +
+                    slash.leading.remove(path)),
+            ], []);
+        }
+        return resourceUrls;
+    }
+    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+    /*              PRIVATE METHODS             */
+    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+    /**
+     * Creates final URLs with search keywords
+     */
+    getSearchUrls(searchValue, options) {
+        const { queryPath, port, split, unsecureHttp } = options;
+        const keywords = this.getKeywords(searchValue);
+        const urls = this.getSearchPathUrls({
+            queryPath,
+            port,
+            unsecureHttp,
+        });
+        if (split) {
+            return keywords.reduce((result, keyword) => [
+                ...result,
+                ...urls.map((url) => this.getHref(url + keyword)),
+            ], []);
+        }
+        return urls.map((url) => this.getHref(url + keywords.join(this.#delimiter)));
+    }
+    /**
+     * Creates URLs by adding the `queryPath` property to the site's
+     * base URL that can be used to query search keywords.
+     *
+     * For example `https://google.com/search?q=`
+     */
+    getSearchPathUrls(options) {
+        const { queryPath, port, unsecureHttp } = options;
+        const baseUrls = this.getBaseUrls({ port, unsecureHttp });
+        const searchPaths = this.getSearchPathValues(queryPath);
+        return baseUrls.reduce((result, baseUrl) => [
+            ...result,
+            ...searchPaths.map((sp) => (baseUrl.endsWith('=') ? baseUrl : slash.trailing.add(baseUrl)) +
+                (sp.startsWith('?') ? sp : slash.leading.remove(sp))),
+        ], []);
+    }
+    /**
+     * Splits the search value into an array of keyword strings
+     */
+    getKeywords(searchValue) {
+        return searchValue
+            .trim()
+            .split(' ')
+            .filter((keyword) => keyword.length > 0);
+    }
+    /**
+     * Creates a URL with a protocol.
+     *
+     * @param unsecureHttp
+     * If provided and URL string includes a protocol,
+     * the URL's protocol will be overridden
+     */
+    getUrlWithProtocol(url, unsecureHttp) {
+        const protocol = `http${unsecureHttp ? '' : 's'}://`;
+        const hasProtocol = matchers.protocol.test(url);
+        return hasProtocol && unsecureHttp == null
+            ? url
+            : `${protocol}${removeProtocol(url)}`;
+    }
+    /**
+     * Creates a URL with a port
+     */
+    getUrlWithPort(url, port) {
+        const protocol = extractProtocol(url) ?? '';
+        const noProtocolUrl = removeProtocol(url);
+        function hasPort() {
+            return matchers.port.test(url);
+        }
+        function buildUrl() {
+            const matches = noProtocolUrl.match(matchers.port);
+            // provided URL includes a port
+            if (matches != null) {
+                const [, currentPort] = matches;
+                const colon = ':';
+                const i = noProtocolUrl.indexOf(colon);
+                // provided port is not part of the url
+                if (currentPort !== port.toString() && i >= 0) {
+                    const beforePort = noProtocolUrl.substring(0, i);
+                    const afterPort = noProtocolUrl.substring(i + colon.length + currentPort.length);
+                    return `${protocol}${beforePort}:${port}${afterPort}`;
+                }
+                // provided port is already part of the url
+                return url;
+            }
+            // provided URL does not include a port
+            const i = noProtocolUrl.indexOf('/');
+            const host = i > 0 ? noProtocolUrl.substring(0, i) : noProtocolUrl;
+            const path = i > 0 ? noProtocolUrl.substring(i) : '';
+            return `${protocol}${host}:${port}${path}`;
+        }
+        const urlWithPort = buildUrl();
+        return hasPort() && urlWithPort !== url
+            ? [url, urlWithPort]
+            : [urlWithPort];
+    }
+    /**
+     * Returns an array of `queryPath` values provided for the current `search` call
+     *
+     * - If `queryPath` is not provided or is invalid, defaults to the site's
+     * main `search` value
+     *
+     * - If site does not have a main `search` value, default to the
+     * site's root (effectively querying the base url)
+     */
+    getSearchPathValues(queryPath) {
+        if (typeof queryPath === 'string') {
+            return [queryPath];
+        }
+        if (Array.isArray(queryPath) &&
+            queryPath.every((sp) => typeof sp === 'string')) {
+            return queryPath;
+        }
+        const { query: configQuery } = this.#config;
+        if (queryPath != null && queryPath instanceof Function) {
+            const result = returnTypeGuard(queryPath, configQuery);
+            if (result != null) {
+                return Array.isArray(result) ? result : [result];
+            }
+        }
+        // fallback to the site's root (base url)
+        let defaultSearchPath = '/';
+        // set the default to the site config's main value, if it exists
+        if (configQuery != null) {
+            if (typeof configQuery === 'string') {
+                defaultSearchPath = configQuery;
+            }
+            else if (configQuery instanceof Object && 'main' in configQuery) {
+                defaultSearchPath = configQuery.main;
+            }
+        }
+        return [defaultSearchPath];
+    }
+    /**
+     * Returns an array of resources for the current `resource` call.
+     *
+     * - If resource is not provided or is invalid, returns an empty array
+     */
+    getResourceValues(resourceValue) {
+        if (typeof resourceValue === 'string') {
+            return [resourceValue];
+        }
+        if (Array.isArray(resourceValue) &&
+            resourceValue.every((r) => typeof r === 'string')) {
+            return resourceValue;
+        }
+        if (resourceValue != null && resourceValue instanceof Function) {
+            const result = returnTypeGuard(resourceValue, this.#config.resources);
+            if (result != null) {
+                return Array.isArray(result) ? result : [result];
+            }
+        }
+        return [];
+    }
+    /**
+     * Returns an array of unique port numbers
+     */
+    getUniquePorts(ports) {
+        return [...new Set(Array.isArray(ports) ? ports : [ports])];
+    }
+    /**
+     * Returns a property formatted URL string
+     */
+    getHref(url) {
+        return new URL(url).href;
+    }
+}

package/dist/api/site/site.types.js

@@ -0,0 +1 @@
+export {};

package/dist/api/utils/extract-protocol.js

@@ -0,0 +1,10 @@
+/**
+ * Return the protocol or an empty string
+ * if the url string has no protocol
+ */
+export function extractProtocol(url) {
+    const delimiter = '://';
+    return url.startsWith('http') && url.includes(delimiter)
+        ? url.substring(0, url.indexOf(delimiter) + delimiter.length)
+        : null;
+}

package/dist/api/utils/remove-protocol.js

@@ -0,0 +1,8 @@
+/**
+ * Return a string without https:// or http://
+ */
+export function removeProtocol(url) {
+    return url.startsWith('https://') || url.startsWith('http://')
+        ? url.split('://')[1]
+        : url;
+}

package/dist/api/utils/return-type-guard.js

@@ -0,0 +1,7 @@
+/**
+ * Higher-order function that returns the callback's
+ * return value or undefined for TypeScript purposes.
+ */
+export function returnTypeGuard(callback, ...args) {
+    return callback(...args);
+}

package/dist/api/utils/slash.js

@@ -0,0 +1,21 @@
+import { matchers } from '../matchers/matchers.js';
+export const slash = {
+    leading: {
+        add(value) {
+            return matchers.slash.leading.test(value) ? value : `/${value}`;
+        },
+        remove(value) {
+            return matchers.slash.leading.test(value) ? value.substring(1) : value;
+        },
+    },
+    trailing: {
+        add(value) {
+            return matchers.slash.trailing.test(value) ? value : `${value}/`;
+        },
+        remove(value) {
+            return matchers.slash.trailing.test(value)
+                ? value.substring(0, value.length - 1)
+                : value;
+        },
+    },
+};

package/dist/command/args/config-args.js

@@ -0,0 +1,9 @@
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { ConfigOptions as Options } from '../options.js';
+export const configArgs = yargs(hideBin(process.argv))
+    .option(Options.Config, {
+    type: 'boolean',
+})
+    .help(false)
+    .parseSync();

package/dist/command/args/data-args.js

@@ -0,0 +1,110 @@
+import { configProfileFlags } from '../../config/config-flags.js';
+import { sitesData, browsersData, getProfilesData } from '../../data/config-data.js';
+import { queryOptions } from '../options.js';
+import { queryArgs } from './query-args.js';
+/**
+ * Returns a combined list of values that were supplied to the CLI
+ * as standard options and custom flags
+ */
+function combineArgLists(optionArg, customArgs = []) {
+    const argList = [...customArgs];
+    if (optionArg != null) {
+        argList.push(...(Array.isArray(optionArg) ? optionArg : [optionArg]));
+    }
+    return argList;
+}
+/**
+ * Returns a unique list of non-nullable args
+ */
+function getUniqueList(optionArg, customArgs = [], removeEmptyArg = true) {
+    const list = combineArgLists(optionArg, customArgs);
+    const uniqueList = [...new Set(list)];
+    return removeEmptyArg ? uniqueList.filter((arg) => arg !== '') : uniqueList;
+}
+/**
+ * Returns a list of arg options supplied to the CLI that are
+ * specific to config data and do not match standard args
+ */
+function getCustomArgs(data) {
+    const customFlags = Object.keys(queryArgs).filter((key) => !queryOptions.includes(key));
+    return Object.entries(data)
+        .map(([key, { alias }]) => {
+        if (alias != null) {
+            return Array.isArray(alias) ? [key, ...alias] : [key, alias];
+        }
+        return key;
+    })
+        .flat()
+        .filter((nameOrAlias) => customFlags.includes(nameOrAlias));
+}
+export const dataArgs = {
+    /**
+     * Returns a unique list of browser args provided to the CLI
+     *
+     * @param removeEmptyArg
+     * If true, removes the empty value from the list
+     */
+    browser: function getBrowserArgs(removeEmptyArg = true) {
+        const customArgs = getCustomArgs(browsersData);
+        return getUniqueList(queryArgs.browser, customArgs, removeEmptyArg);
+    },
+    /**
+     * Returns a unique list of profile args provided to the CLI.
+     *
+     * @param browserName
+     * If value is provided, returns profile args for that browser name,
+     * otherwise returns all profile args supplied to the CLI
+     *
+     * @param removeEmptyArg
+     * If true, removes an empty arg value from the list
+     */
+    profile: function getProfileArgs(browserName, removeEmptyArg = true) {
+        const { profile } = queryArgs;
+        if (browserName == null) {
+            const list = [];
+            // push option arg values (--profile <name>) to the list
+            if (profile != null) {
+                list.push(...(Array.isArray(profile) ? profile : [profile]));
+            }
+            // push custom args (--profileName) to the list
+            Object.keys(browsersData).forEach((arg) => {
+                const profilesData = getProfilesData(arg);
+                const customArgs = getCustomArgs(profilesData);
+                // filter out short aliases
+                const profileArgs = customArgs.filter((profileArg) => configProfileFlags.includes(profileArg));
+                list.push(...profileArgs);
+            });
+            return [
+                ...new Set(removeEmptyArg ? list.filter((arg) => arg !== '') : list),
+            ];
+        }
+        const profilesData = getProfilesData(browserName);
+        const customArgs = getCustomArgs(profilesData);
+        // filter out short aliases
+        const profileArgs = customArgs.filter((profileArg) => configProfileFlags.includes(profileArg));
+        return getUniqueList(profile, profileArgs, removeEmptyArg);
+    },
+    /**
+     * Returns a unique list of site args provided to the CLI
+     *
+     * @param removeEmptyArg
+     * If true, removes the empty value from the list
+     */
+    site: function getSiteArgs(removeEmptyArg = true) {
+        const customArgs = getCustomArgs(sitesData);
+        return getUniqueList(queryArgs.site, customArgs, removeEmptyArg);
+    },
+    /**
+     * Returns a unique list of port args provided to the CLI
+     *
+     * @param removeEmptyArg
+     * If true, removes the empty value from the list
+     */
+    port: function getPortArgs() {
+        const ports = Array.isArray(queryArgs.port)
+            ? queryArgs.port
+            : [queryArgs.port];
+        const uniquePorts = [...new Set(ports)];
+        return uniquePorts.filter((port) => port != null);
+    },
+};

package/dist/command/args/invalid-args.js

@@ -0,0 +1,11 @@
+import { configFlags } from '../../config/config-flags.js';
+import { queryOptions, yargsOptions } from '../options.js';
+import { queryArgs } from './query-args.js';
+/**
+ * A list of args that do not match CLI and yargs' options,
+ * or the custom flags derived from the config's site, browser,
+ * and profile values. Does not check against config options.
+ */
+export const invalidArgs = Object.keys(queryArgs)
+    .filter((key) => !yargsOptions.includes(key))
+    .filter((key) => ![...queryOptions, ...configFlags].includes(key));