@lexjs/web 2.0.0

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

@@ -0,0 +1,121 @@
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { matchers } from '../../api/matchers/matchers.js';
+import { configFlags } from '../../config/config-flags.js';
+import { getPackageInfo } from '../../utils/get-package-info.js';
+import { QueryOptions as Options, queryAlias as alias, queryOptions as options, queryOptionTypes as types, } from '../options.js';
+const version = getPackageInfo().version;
+const group = {
+    browser: 'Browser Options:',
+    site: 'Site Options:',
+    other: 'Other Options:',
+};
+const parsed = yargs(hideBin(process.argv))
+    .option(Options.Browser, {
+    type: types[Options.Browser],
+    alias: alias.browser,
+    description: 'The browser app to open',
+    group: group.browser,
+})
+    .option(Options.Profile, {
+    type: types[Options.Profile],
+    alias: alias.profile,
+    description: 'The browser profile to open',
+    group: group.browser,
+})
+    .option(Options.Incognito, {
+    type: types[Options.Incognito],
+    alias: alias.incognito,
+    description: 'Open in incognito / private mode',
+    group: group.browser,
+})
+    .option(Options.Site, {
+    type: types[Options.Site],
+    alias: alias.site,
+    description: 'The website to search',
+    group: group.site,
+})
+    .option(Options.Query, {
+    type: types[Options.Query],
+    alias: alias.query,
+    description: "The website's query path to use for searching",
+    group: group.site,
+})
+    .option(Options.Resource, {
+    type: types[Options.Resource],
+    alias: alias.resource,
+    description: "The website's resource to access",
+    group: group.site,
+})
+    .option(Options.Delimiter, {
+    type: types[Options.Delimiter],
+    alias: alias.delimiter,
+    description: "The website's delimiter to separate search terms",
+    group: group.site,
+})
+    .option(Options.Port, {
+    type: types[Options.Port],
+    alias: alias.port,
+    description: 'The port number to add to the URL',
+    group: group.site,
+})
+    .option(Options.Http, {
+    type: types[Options.Http],
+    alias: alias.http,
+    description: 'Use the HTTP (non-secure) protocol',
+    group: group.site,
+})
+    .option(Options.Split, {
+    type: types[Options.Split],
+    alias: alias.split,
+    description: 'Create a separate search query for each search term',
+    group: group.other,
+})
+    .option(Options.DryRun, {
+    type: types[Options.DryRun],
+    alias: alias['dry-run'],
+    description: 'Display the output without opening browser tabs',
+    group: group.other,
+})
+    .middleware((argv) => {
+    for (const key of Object.keys(argv)) {
+        if (key === 'dry-run' && !('dryrun' in argv)) {
+            argv.dryrun = argv[key];
+        }
+    }
+})
+    .help()
+    .version(version)
+    .hide('help')
+    .hide('version')
+    .boolean(configFlags.filter((flag) => !options.includes(flag)))
+    .parserConfiguration({
+    'boolean-negation': false,
+})
+    .parseSync();
+const args = parsed;
+const arrayArgs = {
+    browser: args.browser,
+    profile: args.profile,
+    site: args.site,
+    query: args.query,
+    resource: args.resource,
+    port: args.port,
+};
+const _ = args._.map((arg) => `${arg}`);
+const urlsOnly = _.length > 0 && _.every((arg) => matchers.url.test(arg));
+/**
+ * Is populated only if all value args are URLs
+ */
+const urlArgs = urlsOnly ? _ : undefined;
+const queryArgs = {
+    ...args,
+    ...arrayArgs,
+    _,
+};
+for (const key of Object.keys(queryArgs)) {
+    if (args[key] == null) {
+        delete queryArgs[key];
+    }
+}
+export { queryArgs, urlArgs };

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

@@ -0,0 +1,126 @@
+import chalk from 'chalk';
+import { matchers } from '../../api/matchers/matchers.js';
+import { configSiteFlags, browserProfileFlags } from '../../config/config-flags.js';
+import { defaultsData } from '../../data/defaults.js';
+import { getBrowserName } from '../../helpers/get-browser-name.js';
+import { logger } from '../../utils/logger.js';
+import { QueryOptions as Options } from '../options.js';
+import { dataArgs } from './data-args.js';
+import { invalidArgs } from './invalid-args.js';
+import { queryArgs, urlArgs } from './query-args.js';
+const { italic } = chalk;
+const { resource, query, delimiter } = queryArgs;
+const siteArgs = dataArgs.site(false);
+const browserArgs = dataArgs.browser(false);
+const portArgs = dataArgs.port();
+const validate = {
+    profiles: false,
+};
+const errorMessages = [];
+function addMessage(message) {
+    errorMessages.push(message);
+}
+function isEmptyArg(list) {
+    return list.length === 1 && list[0] === '';
+}
+function noValueError(option) {
+    addMessage(logger.level.error(`${italic(`--${option}`)} option must have a value`));
+}
+function validateResource(value, option, allowUrlArgs = true) {
+    const emptyArg = !Array.isArray(value) && value === '';
+    const emptyList = Array.isArray(value) && value.every((arg) => arg === '');
+    if (emptyArg || emptyList) {
+        noValueError(option);
+    }
+    if (siteArgs.length === 0 && (!allowUrlArgs || !urlArgs)) {
+        addMessage(logger.level.error(`${italic(`--${option}`)} option must be used with --engine${allowUrlArgs ? ' or URL' : ''}`));
+    }
+}
+/**
+ * Validates profile args
+ *
+ * @param browser
+ * * If a single string is provided - profile args are checked against
+ * profile keys and aliases of the provided config browser
+ * * String array, null or undefined - profile args are validated against
+ * profile keys and aliases of all config browsers
+ */
+function validateProfileArgs(browser) {
+    const profileArgs = dataArgs.profile(browser == null || Array.isArray(browser) ? null : browser, false);
+    if (isEmptyArg(profileArgs)) {
+        noValueError(Options.Profile);
+    }
+    let flags = {};
+    if (browser != null) {
+        (Array.isArray(browser) ? browser : [browser]).forEach((browserNameOrAlias) => {
+            const browserName = getBrowserName(browserNameOrAlias);
+            const profileFlags = browserProfileFlags[browserName];
+            flags = {
+                ...flags,
+                [browserName]: profileFlags ?? [],
+            };
+        });
+    }
+    const invalidProfiles = profileArgs.filter((arg) => arg !== '' && !Object.values(flags).flat().includes(arg));
+    if (invalidProfiles.length > 0) {
+        addMessage(logger.level.error(`Invalid profiles: ${logger.level.warning(invalidProfiles.join(' '))}`));
+    }
+}
+/**
+ * Returns an array of error messages with invalid args
+ * (empty array if all args are valid)
+ */
+export function validateArgs() {
+    /* ~~~ VALIDATE CLI ARGS ~~~ */
+    if (invalidArgs.length > 0) {
+        addMessage(logger.level.error(`Invalid options: ${logger.level.warning(invalidArgs.join(', '))}`));
+    }
+    /* ~~~ VALIDATE SITE ARGS ~~~  */
+    if (isEmptyArg(siteArgs)) {
+        noValueError(Options.Site);
+    }
+    const invalidSites = siteArgs.filter((arg) => arg !== '' && !configSiteFlags.includes(arg) && !matchers.url.test(arg));
+    if (invalidSites.length > 0) {
+        addMessage(logger.level.error(`Invalid sites: ${logger.level.warning(invalidSites.join(' '))}`));
+    }
+    /* ~~~ VALIDATE RESOURCE ARGS ~~~ */
+    if (resource != null) {
+        validateResource(resource, Options.Resource);
+    }
+    /* ~~~ VALIDATE SEARCH ARGS ~~~ */
+    if (query != null) {
+        validateResource(query, Options.Query, false);
+    }
+    /* ~~~ VALIDATE DELIMITER ARGS ~~~ */
+    if (delimiter != null) {
+        if (Array.isArray(delimiter)) {
+            addMessage(logger.level.error(`Multiple ${italic('--delimiter')} options are not allowed`));
+        }
+        if (delimiter === '') {
+            noValueError(Options.Delimiter);
+        }
+    }
+    /**
+     * ~~~ VALIDATE BROWSER ARGS ~~~
+     *
+     * Only an empty browser option should is checked.
+     * A browser value that does not exist in the config should still be valid
+     * because it is an app that should be attempted to open
+     */
+    if (isEmptyArg(browserArgs)) {
+        noValueError(Options.Browser);
+    }
+    /* ~~~ VALIDATE PROFILE ARGS ~~~ */
+    if (validate.profiles) {
+        validateProfileArgs(browserArgs.length > 0 ? browserArgs : defaultsData.browser?.[0]);
+    }
+    /* ~~~ VALIDATE PORT ARGS ~~~ */
+    if (portArgs.length > 0) {
+        if (portArgs.some((port) => Number.isNaN(port))) {
+            addMessage(logger.level.error(`${italic('--port')} option must be a number`));
+        }
+        if (siteArgs.length === 0 && !urlArgs)
+            addMessage(logger.level.error(`${italic('--port')} option must be used with --engine or URL`));
+    }
+    return errorMessages.sort((a, b) => a.localeCompare(b));
+}

package/dist/command/options.js

@@ -0,0 +1,58 @@
+export const yargsOptions = ['_', '$0'];
+// QUERY OPTIONS
+export var QueryOptions;
+(function (QueryOptions) {
+    QueryOptions["Browser"] = "browser";
+    QueryOptions["Profile"] = "profile";
+    QueryOptions["Site"] = "site";
+    QueryOptions["Query"] = "query";
+    QueryOptions["Resource"] = "resource";
+    QueryOptions["Delimiter"] = "delimiter";
+    QueryOptions["Port"] = "port";
+    QueryOptions["Incognito"] = "incognito";
+    QueryOptions["Split"] = "split";
+    QueryOptions["Http"] = "http";
+    QueryOptions["DryRun"] = "dry-run";
+})(QueryOptions || (QueryOptions = {}));
+export const queryOptionTypes = {
+    [QueryOptions.Browser]: 'string',
+    [QueryOptions.Profile]: 'string',
+    [QueryOptions.Site]: 'string',
+    [QueryOptions.Query]: 'string',
+    [QueryOptions.Resource]: 'string',
+    [QueryOptions.Delimiter]: 'string',
+    [QueryOptions.Port]: 'number',
+    [QueryOptions.Incognito]: 'boolean',
+    [QueryOptions.Split]: 'boolean',
+    [QueryOptions.Http]: 'boolean',
+    [QueryOptions.DryRun]: 'boolean',
+};
+export const queryAlias = {
+    browser: ['b'],
+    profile: ['p'],
+    site: ['s'],
+    query: ['q'],
+    resource: ['r'],
+    delimiter: ['d'],
+    port: [':'],
+    incognito: ['i'],
+    'dry-run': ['n'],
+};
+/**
+ * CLI options and their aliases (excluding config options)
+ */
+export const queryOptions = [
+    ...Object.values(QueryOptions),
+    ...Object.values(queryAlias).flat(),
+    'dryRun',
+    'dryrun',
+];
+// CONFIG OPTIONS
+export var ConfigOptions;
+(function (ConfigOptions) {
+    ConfigOptions["Config"] = "config";
+})(ConfigOptions || (ConfigOptions = {}));
+/**
+ * CLI options and their aliases related to config
+ */
+export const configOptions = Object.values(ConfigOptions);

package/dist/config/config-file.js

@@ -0,0 +1,66 @@
+import path from 'node:path';
+import $_ from '@lexjs/prompts';
+import { openApp } from 'open';
+import { useCoreActions } from '../actions/core-actions.js';
+import { appData, writeAppData } from '../data/app-data.js';
+import { logger } from '../utils/logger.js';
+import { yamlFiles } from '../utils/yaml-files.js';
+import { CONFIG_FILE } from '../constants.js';
+import { updateFileEditor } from './file-editor.js';
+const configChoices = [
+    { title: 'Sites', value: 'sites' },
+    { title: 'Browsers', value: 'browsers' },
+];
+function normalizeChoiceArg(arg) {
+    const configOptions = ['browsers', 'sites'];
+    return configOptions.find((option) => arg != null && option.startsWith(arg));
+}
+const configDir = useCoreActions(({ config }) => config);
+export function configFileExists(option) {
+    const configName = CONFIG_FILE(option);
+    return !!yamlFiles(configName).find((file) => configDir.exists(file));
+}
+export function getConfigFileName(option) {
+    const configName = CONFIG_FILE(option);
+    return (yamlFiles(configName).find((file) => configDir.exists(file)) ?? configName);
+}
+export function getConfigFilePath(option) {
+    const configName = getConfigFileName(option);
+    return path.join(configDir.getPath(), configName);
+}
+export function createInitialConfig(option) {
+    const configName = getConfigFileName(option);
+    configDir.writeFile(configName, `$schema: ../schema/${option}.json
+
+`);
+}
+export async function openConfigFile(arg) {
+    const editor = appData.editor ?? (await updateFileEditor());
+    if (editor == null)
+        return;
+    const choiceArg = normalizeChoiceArg(arg);
+    const isConfigChoice = choiceArg === 'sites' || choiceArg === 'browsers';
+    let configOption = isConfigChoice
+        ? choiceArg
+        : undefined;
+    if (choiceArg == null || !isConfigChoice) {
+        const { selectedConfig } = await $_.select({
+            name: 'selectedConfig',
+            message: 'Select config to edit',
+            choices: configChoices,
+        });
+        configOption = selectedConfig;
+    }
+    if (configOption == null)
+        return;
+    if (!configFileExists(configOption)) {
+        createInitialConfig(configOption);
+    }
+    const subprocess = await openApp(editor, {
+        arguments: [getConfigFilePath(configOption)],
+    });
+    subprocess.on('error', () => {
+        writeAppData({ editor: undefined });
+        logger.error('Error opening file editor:', editor);
+    });
+}

package/dist/config/config-flags.js

@@ -0,0 +1,42 @@
+import { browsersData, sitesData, getProfilesData } from '../data/config-data.js';
+/**
+ * Returns a flat array of names and aliases from the config
+ * based on the provided config data
+ */
+function getFlags(data, includeSingleLetterAlias = true) {
+    return Object.entries(data)
+        .map(([key, { alias }]) => {
+        if (alias != null) {
+            const aliases = Array.isArray(alias) ? alias : [alias];
+            const filter = (a) => includeSingleLetterAlias || a.length > 1;
+            return [key, ...aliases.filter(filter)];
+        }
+        return key;
+    })
+        .flat();
+}
+/** a list of all browser keys and aliases in the config */
+export const configBrowserFlags = getFlags(browsersData);
+/** profile keys and aliases per each browser */
+export const browserProfileFlags = {};
+/** a list of all profile keys WITHOUT aliases in the config */
+export const configProfileFlags = Object.keys(browsersData)
+    .map((browserName) => {
+    const profilesData = getProfilesData(browserName);
+    browserProfileFlags[browserName] = getFlags(profilesData);
+    return getFlags(profilesData, false);
+})
+    .flat();
+/** a list of all site keys and aliases in the config */
+export const configSiteFlags = getFlags(sitesData);
+/**
+ * A list of identifiers (keys and aliases) from config data:
+ * - browsers
+ * - profiles (no aliases)
+ * - sites
+ */
+export const configFlags = [
+    ...configBrowserFlags,
+    ...configProfileFlags,
+    ...configSiteFlags,
+];

package/dist/config/file-editor.js

@@ -0,0 +1,26 @@
+import $_ from '@lexjs/prompts';
+import { writeAppData } from '../data/app-data.js';
+import { VS_CODE } from '../constants.js';
+export async function updateFileEditor() {
+    const { useVsCode } = await $_.confirm({
+        name: 'useVsCode',
+        message: 'Use VSCode to edit config?',
+        initial: true,
+    });
+    if (useVsCode == null)
+        return undefined;
+    if (useVsCode) {
+        writeAppData({ editor: VS_CODE });
+        return VS_CODE;
+    }
+    const { editor } = await $_.text({
+        name: 'editor',
+        message: 'Command to launch file editor',
+        validate: (value) => value !== '',
+    });
+    if (editor != null && editor !== '') {
+        writeAppData({ editor });
+        return editor;
+    }
+    return undefined;
+}

package/dist/config/handle-config.js

@@ -0,0 +1,12 @@
+import { configArgs } from '../command/args/config-args.js';
+import { openConfigFile } from './config-file.js';
+import { updateFileEditor } from './file-editor.js';
+const _ = configArgs._.map((arg) => `${arg}`);
+export async function handleConfig() {
+    const arg = _.at(0);
+    if (arg === 'editor') {
+        await updateFileEditor();
+        return;
+    }
+    await openConfigFile(arg);
+}

package/dist/constants.js

@@ -0,0 +1,15 @@
+import os from 'node:os';
+import { getPackageInfo } from './utils/get-package-info.js';
+const NODE_ENV = process.env.NODE_ENV;
+export const PACKAGE_NAME = getPackageInfo().name;
+export const PACKAGE_NAMESPACE = PACKAGE_NAME.split('/')[0].substring(1);
+export const APP_NAME = PACKAGE_NAME.split('/')[1];
+export const IS_WINDOWS = os.platform() === 'win32';
+export const IS_DEV = NODE_ENV === 'development' || NODE_ENV === 'dev';
+export const DATA_FILE = 'data.json';
+export const CONFIG_FILE = (option) => `${option}.yml`;
+export const BASE_SCHEMA_FILE = 'base.json';
+export const SITES_SCHEMA_FILE = 'sites.json';
+export const BROWSERS_SCHEMA_FILE = 'browsers.json';
+export const COMMAND_FALLBACK = 'web';
+export const VS_CODE = 'code';

package/dist/create-app/main.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { createTree, FileTree } from '@lexjs/filetree';
+import { coreActions } from '@lexjs/filetree/actions';
+import $_ from '@lexjs/prompts';
+import chalk from 'chalk';
+import { useCoreActions } from '../actions/core-actions.js';
+import { npmCommands, npmActions } from '../actions/npm-actions.js';
+import { permissionActions } from '../actions/permission-actions.js';
+import { appData } from '../data/app-data.js';
+import { getPackageInfo } from '../utils/get-package-info.js';
+import { logger } from '../utils/logger.js';
+import { configFileExists, createInitialConfig, } from '../config/config-file.js';
+import { DATA_FILE, IS_DEV, IS_WINDOWS, PACKAGE_NAME, COMMAND_FALLBACK, } from '../constants.js';
+import { paths } from './paths.js';
+import { bashScript, bashStartScript, powershellScript, } from './script-contents.js';
+import { initialTree, tree } from './tree.js';
+function isEmpty(str) {
+    return str == null || str === '';
+}
+async function getCommand() {
+    let command;
+    const rootDir = useCoreActions((root) => root);
+    if (rootDir.exists(DATA_FILE)) {
+        command = appData.command;
+    }
+    let renameCommand = false;
+    if (!isEmpty(command)) {
+        logger.warning(`${PACKAGE_NAME} command is set as ${chalk.underline(command)}\n`);
+        const { rename } = await $_.toggle({
+            message: 'Do you want to rename it?',
+            name: 'rename',
+        });
+        if (rename == null)
+            return undefined;
+        renameCommand = rename;
+    }
+    if (isEmpty(command) || renameCommand) {
+        const { commandName } = await $_.text({
+            name: 'commandName',
+            message: 'What should be the command name?',
+            initial: COMMAND_FALLBACK,
+        });
+        if (commandName == null)
+            return undefined;
+        command = commandName;
+    }
+    return command;
+}
+function ensureNamespace() {
+    const fileTree = new FileTree(paths.namespace, {});
+    if (!fs.existsSync(paths.namespace)) {
+        createTree(fileTree);
+    }
+}
+async function initializeApp(command) {
+    const fileTree = new FileTree(paths.root, initialTree);
+    ensureNamespace();
+    createTree(fileTree);
+    // create data and config files
+    const useCore = fileTree.use(coreActions);
+    const rootDir = useCore((root) => root);
+    rootDir.createFile(DATA_FILE, JSON.stringify({ ...appData, command }));
+    const configOptions = ['browsers', 'sites'];
+    configOptions.forEach((option) => {
+        if (!configFileExists(option)) {
+            createInitialConfig(option);
+        }
+    });
+    // install package (link in development)
+    const version = IS_DEV ? '' : getPackageInfo().version;
+    const pkg = version != null && version !== ''
+        ? `${PACKAGE_NAME}@${version}`
+        : PACKAGE_NAME;
+    const npmCommand = IS_DEV ? npmCommands.link : npmCommands.install;
+    const useNpm = fileTree.use(npmActions);
+    await useNpm(({ lib }) => lib)[npmCommand]([pkg]);
+}
+function linkDist() {
+    const distDir = useCoreActions(({ lib }) => lib.node_modules[PACKAGE_NAME].dist).getPath();
+    if (fs.existsSync(paths.distLink)) {
+        fs.rmSync(paths.distLink, { force: true, recursive: true });
+    }
+    fs.symlinkSync(distDir, paths.distLink, IS_WINDOWS ? 'junction' : 'dir');
+}
+async function createScriptFiles(command) {
+    const [rootDir, binDir] = useCoreActions((root) => [root, root.bin]);
+    const scriptNames = { bash: command, powershell: `${command}.ps1` };
+    const { bash, powershell } = scriptNames;
+    // delete files that are not named based on the command
+    const binFiles = fs.readdirSync(binDir.getPath());
+    binFiles
+        .filter((file) => {
+        const filePath = path.join(binDir.getPath(), file);
+        const isCommandFile = Object.values(scriptNames).includes(file);
+        return fs.statSync(filePath).isFile() && !isCommandFile;
+    })
+        .forEach((file) => {
+        binDir.deleteFile(file);
+    });
+    const fileTree = new FileTree(paths.root, tree);
+    const usePermissions = fileTree.use(permissionActions);
+    const binPermissions = usePermissions(({ bin }) => bin);
+    // create script files
+    rootDir.createFile('start.sh', bashStartScript);
+    binDir.createFile(bash, bashScript);
+    await binPermissions.x(bash);
+    if (IS_WINDOWS) {
+        binDir.createFile(powershell, powershellScript);
+        await binPermissions.x(bash);
+    }
+}
+(async function createApp() {
+    const command = await getCommand();
+    if (command == null)
+        return;
+    await initializeApp(command);
+    await createScriptFiles(command);
+    linkDist();
+})();

package/dist/create-app/paths.js

@@ -0,0 +1,24 @@
+import os from 'node:os';
+import path from 'node:path';
+import { APP_NAME, PACKAGE_NAMESPACE } from '../constants.js';
+class Paths {
+    get namespace() {
+        return path.join(os.homedir(), `.${PACKAGE_NAMESPACE}`);
+    }
+    get root() {
+        return path.join(this.namespace, APP_NAME);
+    }
+    get bin() {
+        return path.join(this.root, 'bin');
+    }
+    get lib() {
+        return path.join(this.root, 'lib');
+    }
+    get distLink() {
+        return path.join(this.root, '.dist');
+    }
+    get main() {
+        return path.join(this.distLink, 'main.js');
+    }
+}
+export const paths = new Paths();

package/dist/create-app/schema/base.json

@@ -0,0 +1,21 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "$defs": {
+        "alias": {
+            "oneOf": [
+                { "type": "string" },
+                { "type": "array", "items": { "type": "string" } }
+            ]
+        },
+        "NestedStringObject": {
+            "type": "object",
+            "additionalProperties": {
+                "oneOf": [
+                    { "$ref": "#/$defs/NestedStringObject" },
+                    { "type": "string" }
+                ]
+            }
+        }
+    }
+}