@lexjs/web 2.0.0

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

@@ -0,0 +1,60 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Browsers Config",
+    "type": "object",
+    "properties": {
+        "$schema": {
+            "type": "string"
+        }
+    },
+    "additionalProperties": {
+        "oneOf": [{ "$ref": "#/$defs/Browser" }, { "type": "null" }]
+    },
+    "$defs": {
+        "Browser": {
+            "description": "Browser config definition",
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "default": {
+                    "type": "boolean",
+                    "description": "If true, this browser is considered a default option."
+                },
+                "alias": {
+                    "$ref": "base.json#/$defs/alias",
+                    "description": "One or more aliases for the browser."
+                },
+                "appPath": {
+                    "description": "Path to the browser executable.",
+                    "type": "string"
+                },
+                "profiles": {
+                    "description": "Profile definitions for this browser.",
+                    "type": "object",
+                    "additionalProperties": {
+                        "oneOf": [{ "$ref": "#/$defs/Profile" }, { "type": "string" }]
+                    }
+                }
+            }
+        },
+        "Profile": {
+            "description": "Defines a specific user profile for a browser.",
+            "type": "object",
+            "properties": {
+                "directory": {
+                    "description": "Name of directory where profile data is stored.",
+                    "type": "string"
+                },
+                "default": {
+                    "type": "boolean",
+                    "description": "If true, this profile is considered a default option."
+                },
+                "alias": {
+                    "$ref": "base.json#/$defs/alias",
+                    "description": "One or more aliases for the profile."
+                }
+            },
+            "required": ["directory"]
+        }
+    }
+}

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

@@ -0,0 +1,71 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Sites Config",
+    "type": "object",
+    "properties": {
+        "$schema": {
+            "type": "string"
+        }
+    },
+    "additionalProperties": {
+        "$ref": "#/$defs/Site"
+    },
+    "$defs": {
+        "Site": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["url"],
+            "properties": {
+                "url": {
+                    "description": "Primary URL of the site (e.g. 'google.com')",
+                    "type": "string",
+                    "format": "uri"
+                },
+                "query": {
+                    "description": "Query path to search the site (e.g., 'search?q=')",
+                    "oneOf": [{ "$ref": "#/$defs/QueryObject" }, { "type": "string" }]
+                },
+                "default": {
+                    "type": "boolean",
+                    "description": "If true, this site is considered a default option."
+                },
+                "alias": {
+                    "$ref": "base.json#/$defs/alias",
+                    "description": "One or more aliases for the site."
+                },
+                "delimiter": {
+                    "description": "A character or string used to separate search terms.",
+                    "type": "string"
+                },
+                "resources": {
+                    "description": "Resource definitions for specific parts of the site. Supports deep, nested structures.",
+                    "type": "object",
+                    "additionalProperties": {
+                        "oneOf": [
+                            { "$ref": "base.json#/$defs/NestedStringObject" },
+                            { "type": "string" }
+                        ]
+                    }
+                }
+            }
+        },
+        "QueryObject": {
+            "description": "Object describing query path for the site. Supports deep, nested structures.",
+            "type": "object",
+            "properties": {
+                "main": {
+                    "description": "Main query path for the site.",
+                    "type": "string"
+                }
+            },
+            "additionalProperties": {
+                "description": "Additional query path for the site.",
+                "oneOf": [
+                    { "$ref": "base.json#/$defs/NestedStringObject" },
+                    { "type": "string" }
+                ]
+            },
+            "required": ["main"]
+        }
+    }
+}

package/dist/create-app/script-contents.js

@@ -0,0 +1,18 @@
+import { paths } from './paths.js';
+export const bashScript = `#!/usr/bin/env bash
+
+if test -f "${paths.main}"; then
+  node "${paths.main}" "$@"
+fi
+`;
+export const bashStartScript = `#!/usr/bin/env bash
+
+if test -d "${paths.bin}"; then
+	export PATH=${paths.bin}:$PATH
+fi`;
+export const powershellScript = `#!/usr/bin/env pwsh
+
+if (Test-Path -Path "${paths.main}") {
+  node "${paths.main}" $args
+}
+`;

package/dist/create-app/tree.js

@@ -0,0 +1,25 @@
+import { BASE_SCHEMA_FILE, BROWSERS_SCHEMA_FILE, DATA_FILE, PACKAGE_NAME, SITES_SCHEMA_FILE, } from '../constants.js';
+import baseSchema from './schema/base.json' with { type: 'json' };
+import browsersSchema from './schema/browsers.json' with { type: 'json' };
+import sitesSchema from './schema/sites.json' with { type: 'json' };
+export const initialTree = {
+    bin: {},
+    lib: {},
+    config: {},
+    schema: {
+        [BASE_SCHEMA_FILE]: JSON.stringify(baseSchema, null, 2),
+        [SITES_SCHEMA_FILE]: JSON.stringify(sitesSchema, null, 2),
+        [BROWSERS_SCHEMA_FILE]: JSON.stringify(browsersSchema, null, 2),
+    },
+};
+export const tree = {
+    ...initialTree,
+    [DATA_FILE]: '',
+    lib: {
+        node_modules: {
+            [PACKAGE_NAME]: {
+                dist: {},
+            },
+        },
+    },
+};

package/dist/data/app-data.js

@@ -0,0 +1,12 @@
+import { useCoreActions } from '../actions/core-actions.js';
+import { COMMAND_FALLBACK, DATA_FILE } from '../constants.js';
+const defaultAppData = {
+    command: COMMAND_FALLBACK,
+};
+const dataFile = useCoreActions((root) => root[DATA_FILE]);
+const dataRaw = dataFile.read();
+export const appData = dataRaw != null ? JSON.parse(dataRaw) : defaultAppData;
+export function writeAppData(payload) {
+    const newData = { ...appData, ...payload };
+    dataFile.write(JSON.stringify(newData));
+}

package/dist/data/config-data.js

@@ -0,0 +1,35 @@
+import { load } from 'js-yaml';
+import { useCoreActions } from '../actions/core-actions.js';
+import { initialSites } from './initial-sites.js';
+import { yamlFiles } from '../utils/yaml-files.js';
+import { CONFIG_FILE } from '../constants.js';
+import { sortConfigData } from './sort-config-data.js';
+const configDir = useCoreActions(({ config }) => config);
+function readConfig(option) {
+    const found = yamlFiles(CONFIG_FILE(option)).find((fileName) => configDir.exists(fileName));
+    return found != null ? configDir.readFile(found) : null;
+}
+const sitesConfigRaw = readConfig('sites');
+const browsersConfigRaw = readConfig('browsers');
+const configData = { sites: {}, browsers: {} };
+if (sitesConfigRaw != null) {
+    const { $schema, ...sites } = load(sitesConfigRaw);
+    configData.sites = sortConfigData(sites);
+}
+if (browsersConfigRaw != null) {
+    const { $schema, ...browsers } = load(browsersConfigRaw);
+    const sorted = sortConfigData(browsers);
+    // cast null values as empty objects
+    configData.browsers = Object.entries(sorted).reduce((acc, [key, browser]) => {
+        return { ...acc, [key]: browser === null ? {} : browser };
+    }, sorted);
+}
+export { configData };
+export const sitesData = { ...initialSites, ...configData.sites };
+export const browsersData = configData.browsers ?? {};
+export function getProfilesData(browserName) {
+    return Object.entries(browsersData[browserName]?.profiles ?? {}).reduce((acc, [key, value]) => ({
+        ...acc,
+        [key]: typeof value === 'string' ? { directory: value } : value,
+    }), {});
+}

package/dist/data/defaults.js

@@ -0,0 +1,22 @@
+import { sitesData, browsersData, getProfilesData } from './config-data.js';
+const [siteFallback] = Object.entries(sitesData);
+export const defaultDelimiter = ' ';
+function getDefault(data) {
+    const withDefault = Object.entries(data).find(([, item]) => !!item.default);
+    if (withDefault != null)
+        return withDefault;
+    const first = Object.entries(data).at(0);
+    if (first != null)
+        return first;
+    return null;
+}
+const getDefaultProfile = (browserName) => {
+    const profiles = getProfilesData(browserName);
+    return getDefault(profiles);
+};
+export const defaultsData = {
+    delimiter: defaultDelimiter,
+    site: getDefault(sitesData) ?? siteFallback,
+    browser: getDefault(browsersData),
+    profile: getDefaultProfile,
+};

package/dist/data/initial-sites.js

@@ -0,0 +1,36 @@
+export const initialSites = {
+    google: {
+        url: 'google.com',
+        query: 'search?q=',
+    },
+    duckduckgo: {
+        url: 'duckduckgo.com',
+        query: '?q=',
+        delimiter: '+',
+        alias: ['duck'],
+    },
+    github: {
+        url: 'github.com',
+        query: 'search?q=',
+        resources: {
+            tabs: {
+                stars: '?tab=stars',
+                repos: '?tab=repositories',
+                projects: '?tab=projects',
+            },
+        },
+    },
+    mdn: {
+        url: 'developer.mozilla.org',
+        query: 'search?q=',
+    },
+    npm: {
+        url: 'npmjs.com',
+        query: 'search?q=',
+    },
+    youtube: {
+        url: 'youtube.com',
+        query: 'results?search_query=',
+        delimiter: '+',
+    },
+};

package/dist/data/sort-config-data.js

@@ -0,0 +1,17 @@
+export function sortConfigData(config) {
+    const sortedKeys = Object.keys(config);
+    sortedKeys.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+    const [defaultKey] = Object.entries(config).find(([_key, v]) => v?.default) ?? [];
+    const sortReducer = (acc, key) => ({
+        ...acc,
+        [key]: config[key],
+    });
+    return defaultKey != null
+        ? {
+            [defaultKey]: config[defaultKey],
+            ...sortedKeys
+                .filter((key) => key.toLowerCase() !== defaultKey.toLowerCase())
+                .reduce(sortReducer, {}),
+        }
+        : sortedKeys.reduce(sortReducer, {});
+}

package/dist/helpers/find-browser.js

@@ -0,0 +1,9 @@
+import { browsersData } from '../data/config-data.js';
+import { findConfigItem } from './find-config-item.js';
+/**
+ * Returns a tuple with the browser's config key and the Item object
+ * found in the config by provided name or alias. Otherwise returns undefined
+ */
+export function findBrowser(browserNameOrAlias) {
+    return findConfigItem(browserNameOrAlias, browsersData);
+}

package/dist/helpers/find-config-item.js

@@ -0,0 +1,23 @@
+function withAlias(item) {
+    return item instanceof Object && 'alias' in item;
+}
+/**
+ * Returns a tuple with the item's config key and the Item object
+ * found in the config by provided name or alias. Otherwise returns undefined
+ */
+export function findConfigItem(nameOrAlias, list) {
+    return Object.entries(list).find(([key, item]) => {
+        // name is list's key
+        if (nameOrAlias === key) {
+            return true;
+        }
+        // item does not have aliases
+        if (!withAlias(item)) {
+            return false;
+        }
+        // name is item's alias
+        const { alias } = item;
+        return ((Array.isArray(alias) && alias.includes(nameOrAlias)) ||
+            (typeof alias === 'string' && alias === nameOrAlias));
+    });
+}

package/dist/helpers/find-nested.js

@@ -0,0 +1,24 @@
+const isPrimitive = (value) => typeof value === 'boolean' ||
+    typeof value === 'string' ||
+    typeof value === 'number';
+/**
+ * @param objectFallbackValue fallback value that is used when a matched property's value is an object
+ */
+export function findNested(target, lookupKey, objectFallbackValue) {
+    return Object.keys(target).reduce((result, key) => {
+        if (result != null) {
+            return result;
+        }
+        const value = target[key];
+        if (key === lookupKey) {
+            if (isPrimitive(value)) {
+                return value;
+            }
+            return objectFallbackValue;
+        }
+        if (typeof value === 'object') {
+            return findNested(value, lookupKey, objectFallbackValue);
+        }
+        return null;
+    }, null);
+}

package/dist/helpers/find-profile.js

@@ -0,0 +1,11 @@
+import { getProfilesData } from '../data/config-data.js';
+import { findConfigItem } from './find-config-item.js';
+/**
+ * Returns a tuple with the profile's config key and the Profile object
+ * if it can be found in the config by the browser name
+ * and the profile's name or alias. Otherwise returns undefined
+ */
+export function findProfile(browserName, profileNameOrAlias) {
+    const browserProfiles = getProfilesData(browserName);
+    return findConfigItem(profileNameOrAlias, browserProfiles);
+}

package/dist/helpers/find-site.js

@@ -0,0 +1,15 @@
+import { sitesData } from '../data/config-data.js';
+import { initialSites } from '../data/initial-sites.js';
+import { findConfigItem } from './find-config-item.js';
+/**
+ * Returns a tuple with the site's config key and the Site object
+ * if it can be found in the config by the provided name or alias.
+ * Otherwise returns undefined
+ */
+export function findSite(siteArg) {
+    if (siteArg == null) {
+        return undefined;
+    }
+    const hasSitesData = Object.keys(sitesData).length > 0;
+    return findConfigItem(siteArg, hasSitesData ? sitesData : initialSites);
+}

package/dist/helpers/get-browser-name.js

@@ -0,0 +1,9 @@
+import { findBrowser } from './find-browser.js';
+/**
+ * Returns a browser key from the config if it is found
+ * by the provided name or alias, otherwise returns the argument
+ */
+export function getBrowserName(browserNameOrAlias) {
+    const [browserName] = findBrowser(browserNameOrAlias) ?? [];
+    return browserName ?? browserNameOrAlias;
+}

package/dist/helpers/get-query-profiles.js

@@ -0,0 +1,34 @@
+import { dataArgs } from '../command/args/data-args.js';
+import { defaultsData } from '../data/defaults.js';
+import { findProfile } from './find-profile.js';
+function hasProfile(browserName) {
+    return (dataArgs.profile(browserName).length > 0 ||
+        defaultsData.profile(browserName) != null);
+}
+/**
+ * Returns a list of tuples with profile's config key
+ * and the Profile object for a provided browser name
+ */
+export function getQueryProfiles(browserName) {
+    const profiles = [];
+    function handleProfile(profileNameOrAlias) {
+        const found = findProfile(browserName, profileNameOrAlias);
+        profiles.push(found != null
+            ? found
+            : [profileNameOrAlias, { directory: profileNameOrAlias }]);
+    }
+    if (hasProfile(browserName)) {
+        const profileArgs = dataArgs.profile(browserName);
+        const defaultProfile = defaultsData.profile(browserName);
+        if (profileArgs.length > 0) {
+            profileArgs.forEach((profileNameOrAlias) => {
+                handleProfile(profileNameOrAlias);
+            });
+        }
+        else if (defaultProfile != null) {
+            const [profileName] = defaultProfile;
+            handleProfile(profileName);
+        }
+    }
+    return profiles;
+}

package/dist/main.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { configArgs } from './command/args/config-args.js';
+import { handleConfig } from './config/handle-config.js';
+import { query } from './query/query.js';
+import { logger } from './utils/logger.js';
+const { config } = configArgs;
+(async function main() {
+    if (config) {
+        await handleConfig();
+        return;
+    }
+    query();
+})();
+process.on('uncaughtException', (err) => {
+    if (err.code !== 'ENOENT') {
+        logger.error('An error occurred');
+    }
+    process.exit(1);
+});

package/dist/query/get-profiles-config.js

@@ -0,0 +1,10 @@
+import { findBrowser } from '../helpers/find-browser.js';
+export function getProfilesConfig(browserNameOrAlias) {
+    const [, browser] = findBrowser(browserNameOrAlias) ?? [];
+    return browser == null
+        ? undefined
+        : Object.entries(browser.profiles ?? {}).reduce((result, [key, profile]) => ({
+            ...result,
+            [key]: typeof profile === 'string' ? profile : profile.directory,
+        }), {});
+}

package/dist/query/get-query-browsers.js

@@ -0,0 +1,33 @@
+import { Browser } from '../api/browser/browser.js';
+import { dataArgs } from '../command/args/data-args.js';
+import { defaultsData } from '../data/defaults.js';
+import { findBrowser } from '../helpers/find-browser.js';
+import { getProfilesConfig } from './get-profiles-config.js';
+const browserArgs = dataArgs.browser();
+export function getQueryBrowsers() {
+    if (browserArgs.length === 0) {
+        if (defaultsData.browser == null) {
+            return [];
+        }
+        const [defaultBrowserName, defaultBrowser] = defaultsData.browser;
+        return [
+            [
+                defaultBrowserName,
+                new Browser(defaultBrowser.appPath ?? defaultBrowserName, {
+                    profiles: getProfilesConfig(defaultBrowserName),
+                }),
+            ],
+        ];
+    }
+    return browserArgs.map((browserNameOrAlias) => {
+        const [browserName, browser] = findBrowser(browserNameOrAlias) ?? [
+            browserNameOrAlias,
+        ];
+        return [
+            browserName,
+            new Browser(browser?.appPath ?? browserName, {
+                profiles: getProfilesConfig(browserName),
+            }),
+        ];
+    });
+}

package/dist/query/get-query-sites.js

@@ -0,0 +1,49 @@
+import { Site } from '../api/site/site.js';
+import { dataArgs } from '../command/args/data-args.js';
+import { queryArgs, urlArgs } from '../command/args/query-args.js';
+import { defaultsData, defaultDelimiter } from '../data/defaults.js';
+import { findSite } from '../helpers/find-site.js';
+const [defaultSiteName, defaultSite] = defaultsData.site;
+const siteArgs = dataArgs.site();
+const delimiter = queryArgs.delimiter || defaultDelimiter;
+export function getQuerySites() {
+    // create sites based on provided site args
+    if (siteArgs.length > 0) {
+        return siteArgs.map((siteArg) => {
+            const found = findSite(siteArg);
+            if (found == null) {
+                // site arg can be provided as a URL string
+                const site = new Site(siteArg, { delimiter });
+                return [siteArg, site];
+            }
+            const [siteName, site] = found;
+            return [
+                siteName,
+                new Site(site.url, {
+                    query: site.query,
+                    delimiter: site.delimiter,
+                    resources: site.resources,
+                }),
+            ];
+        });
+    }
+    // do no create sites when there are no value args
+    if (queryArgs._.length === 0) {
+        return [];
+    }
+    // create sites when all value args are URLs
+    if (urlArgs != null) {
+        return urlArgs.map((url) => [url, new Site(url, { delimiter })]);
+    }
+    // create default site
+    return [
+        [
+            defaultSiteName,
+            new Site(defaultSite.url, {
+                query: defaultSite.query,
+                delimiter: defaultSite.delimiter,
+                resources: defaultSite.resources,
+            }),
+        ],
+    ];
+}

package/dist/query/get-urls.js

@@ -0,0 +1,85 @@
+import { dataArgs } from '../command/args/data-args.js';
+import { queryArgs, urlArgs } from '../command/args/query-args.js';
+import { findNested } from '../helpers/find-nested.js';
+const { _: args, resource, http } = queryArgs;
+const siteArgs = dataArgs.site();
+const portArgs = dataArgs.port();
+const port = portArgs.length === 0 ? undefined : portArgs;
+// if there are no site args and all value args are URLs,
+// remove URL args from keywords list because they are used as sites
+const keywords = args.filter((keyword) => siteArgs.length > 0 || !urlArgs || !urlArgs.includes(keyword));
+function handleResource(site, resourceValue) {
+    const splitter = '::';
+    function findResourceByValue(resources) {
+        return findNested(resources, resourceValue, resourceValue);
+    }
+    return site.resource((config = {}) => {
+        // NOTE: resource object has a property key containing the splitter
+        const foundResourceValue = findResourceByValue(config);
+        if (foundResourceValue != null) {
+            return foundResourceValue;
+        }
+        const [resourceKey] = resourceValue.split(splitter);
+        const isEscaped = resourceKey.startsWith('/');
+        // do not search in config if resource key starts with slash
+        return isEscaped
+            ? resourceKey.slice(1)
+            : (findNested(config, resourceKey, resourceKey) ?? resourceKey);
+    }, {
+        path(config = {}) {
+            const foundResource = findResourceByValue(config);
+            // Relates to the NOTE in the above callback
+            // Add path found by splitted path key only if resource does not include the splitter
+            if (foundResource == null) {
+                const pathKeys = resourceValue.split(splitter).slice(1);
+                if (pathKeys.length > 0) {
+                    const result = pathKeys
+                        .reduce((acc, pathKey) => {
+                        const isEscaped = pathKey.startsWith('/');
+                        acc.push(
+                        // do not search in config if path key starts with slash
+                        isEscaped
+                            ? pathKey.slice(1)
+                            : (findNested(config, pathKey, pathKey) ?? pathKey));
+                        return acc;
+                    }, [])
+                        .reduce((acc, value) => {
+                        return `${acc}${value.startsWith('?') ? value : `/${value}`}`;
+                    }, '');
+                    return [...keywords, result];
+                }
+            }
+            return keywords;
+        },
+        port,
+        unsecureHttp: http,
+    });
+}
+function handleQueryPath(config = { main: '/' }) {
+    function getQuery(search) {
+        return typeof config !== 'string'
+            ? (findNested(config, search, search) ?? search)
+            : search;
+    }
+    const { query } = queryArgs;
+    if (query == null) {
+        return typeof config === 'string' ? config : config.main;
+    }
+    if (Array.isArray(query)) {
+        return query.map((s) => getQuery(s));
+    }
+    return getQuery(query);
+}
+export function getUrls(site) {
+    if (resource != null) {
+        return Array.isArray(resource)
+            ? resource.map((r) => handleResource(site, r)).flat()
+            : handleResource(site, resource);
+    }
+    return site.search(keywords.join(' '), {
+        queryPath: handleQueryPath,
+        port,
+        split: queryArgs.split,
+        unsecureHttp: queryArgs.http,
+    });
+}