conzo 0.0.8 → 0.0.10

package/Component.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { ReactItem } from './items/types.js';
+type ComponentProps = {
+    item: ReactItem;
+};
+export declare const Component: ({ item }: ComponentProps) => React.JSX.Element;
+export {};

package/Component.js

@@ -0,0 +1,7 @@
+import React from 'react';
+import { EscapeBackToSearch } from './helpers/EscapeBackToSearch.js';
+export const Component = ({ item }) => {
+    const { action: Component, name } = item;
+    return (React.createElement(EscapeBackToSearch, { title: name },
+        React.createElement(Component, null)));
+};

package/ConfirmStatus.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const ConfirmStatus: ({ command }: {
+    command: string;
+}) => React.JSX.Element;

package/ConfirmStatus.js

@@ -0,0 +1,19 @@
+import React, { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import childProcess from 'child_process';
+import { tryCatch } from './helpers/tryCatch.js';
+export const ConfirmStatus = ({ command }) => {
+    const [status, setStatus] = useState('Loading...');
+    useEffect(() => {
+        const { error } = tryCatch(() => childProcess.execSync(command).toString());
+        if (error) {
+            setStatus({ type: 'Failed', error: error.message });
+        }
+        else {
+            setStatus('Done!');
+        }
+    }, [command]);
+    return (React.createElement(Box, null,
+        React.createElement(Text, null, typeof status === 'string' ? status : status.type),
+        typeof status === 'object' && React.createElement(Text, { color: "red" }, status.error)));
+};

package/Conzo.d.ts

@@ -0,0 +1,4 @@
+import { UserConfig } from './config/types.js';
+export declare const createApp: (userConfig?: UserConfig) => {
+    start: () => import("ink").Instance;
+};

package/Conzo.js

@@ -0,0 +1,34 @@
+import React from 'react';
+import meow from 'meow';
+import App from './app.js';
+import { ViewProvider } from './ViewContext.js';
+import { ApplicationsCacheProvider } from './apps/ApplicationsCacheContext.js';
+import { ConfigProvider } from './config/ConfigContext.js';
+import { parseAndValidate } from './config/parseAndValidate.js';
+import { tryCatch } from './helpers/tryCatch.js';
+import { Error, Fallback } from './Error.js';
+import { ErrorBoundary } from 'react-error-boundary';
+import { render } from 'ink';
+meow('conzo', {
+    importMeta: import.meta,
+    flags: {
+        name: {
+            type: 'string',
+        },
+    },
+});
+export const createApp = (userConfig) => {
+    const { value: config, error } = tryCatch(() => parseAndValidate(userConfig));
+    const Conzo = config
+        ? () => (React.createElement(ErrorBoundary, { FallbackComponent: Fallback },
+            React.createElement(ViewProvider, null,
+                React.createElement(ConfigProvider, { config: config },
+                    React.createElement(ApplicationsCacheProvider, null,
+                        React.createElement(App, null))))))
+        : () => React.createElement(Error, { error: error });
+    return {
+        start: () => render(React.createElement(Conzo, null), {
+            exitOnCtrlC: true,
+        }),
+    };
+};

package/Error.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { FallbackProps } from 'react-error-boundary';
+export declare const Error: ({ error }: {
+    error: Error;
+}) => React.JSX.Element;
+export declare const Fallback: ({ error }: FallbackProps) => React.JSX.Element;

package/Error.js

@@ -0,0 +1,20 @@
+import React from 'react';
+import { EscapeBackToSearch } from './helpers/EscapeBackToSearch.js';
+import { Box, Text, useInput } from 'ink';
+export const Error = ({ error }) => {
+    const [showStack, setShowStack] = React.useState(false);
+    // Note: This useInput sometimes conflicts with the parent component's useInput...
+    useInput((input) => {
+        if (input === 's') {
+            setShowStack((prev) => !prev);
+        }
+    });
+    return (React.createElement(EscapeBackToSearch, { title: "Oops..." },
+        React.createElement(Text, null, error.message),
+        React.createElement(Box, { marginTop: 1 }, showStack ? (React.createElement(Text, null, error.stack)) : (React.createElement(Text, null, "S = show stack trace")))));
+};
+// Standalone Error component
+export const Fallback = ({ error }) => {
+    // Call resetErrorBoundary() to reset the error boundary and retry the render.
+    return React.createElement(Text, null, error.message);
+};

package/Footer.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const Footer: () => React.JSX.Element;

package/Footer.js

@@ -0,0 +1,4 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export const Footer = () => (React.createElement(Box, { justifyContent: "flex-end" },
+    React.createElement(Text, null, "conzo")));

package/GoogleChrome.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { BookmarkInfo } from './items/types.js';
+export declare const openChrome: (profile: string, url?: string) => Promise<void>;
+export declare const openBookmark: (bookmark: BookmarkInfo) => void;
+export declare const OpenChrome: ({ url }: {
+    url?: string;
+}) => React.JSX.Element;
+export declare const GoogleChromeWithProfile: ({ url }: {
+    url?: string;
+}) => React.JSX.Element;

package/GoogleChrome.js

@@ -0,0 +1,39 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { useView } from './ViewContext.js';
+import { useConfig } from './config/ConfigContext.js';
+import { spawnProcess } from './helpers/spawnProcess.js';
+import { SelectBox } from './SelectBox.js';
+// Open Google Chrome with the desired profile.
+const DEFAULT_PROFILE = 'Default';
+export const openChrome = async (profile, url) => {
+    await spawnProcess('open', [
+        '-na',
+        'Google Chrome',
+        '--args',
+        `--profile-directory=${profile}`,
+        ...(url ? [url] : []),
+    ]);
+};
+export const openBookmark = (bookmark) => {
+    openChrome(bookmark.profile ?? DEFAULT_PROFILE, bookmark.url);
+};
+export const OpenChrome = ({ url }) => {
+    const { goToView } = useView();
+    const { chromeProfiles } = useConfig();
+    if (!chromeProfiles) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "No Chrome profiles found"),
+            React.createElement(Text, null, "Make sure you have set up your Chrome profiles in the config.")));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, null, "Select your account"),
+        React.createElement(SelectBox, { items: Object.keys(chromeProfiles), onSelect: (account) => {
+                if (chromeProfiles[account])
+                    openChrome(chromeProfiles[account], url);
+                goToView('search');
+            }, width: 30 })));
+};
+export const GoogleChromeWithProfile = ({ url }) => {
+    return React.createElement(OpenChrome, { url: url });
+};

package/Notes.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const Notes: () => React.JSX.Element;

package/Notes.js

@@ -0,0 +1,4 @@
+import { Box, Text } from 'ink';
+import React from 'react';
+export const Notes = () => (React.createElement(Box, null,
+    React.createElement(Text, null, "Notes...")));

package/Search.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { Item } from './items/types.js';
+type Props = {
+    width: number;
+    choose: (item: Item) => void;
+};
+export declare const Search: ({ width, choose }: Props) => React.JSX.Element;
+export {};

package/Search.js

@@ -0,0 +1,123 @@
+import React from 'react';
+import TextInput from 'ink-text-input';
+import { Box, Text, useInput } from 'ink';
+import { useApplicationsCache } from './apps/ApplicationsCacheContext.js';
+import { useConfig } from './config/ConfigContext.js';
+import { useView } from './ViewContext.js';
+import { getItems } from './items/items.js';
+const MAX_VISIBLE_RESULTS = 10;
+const initialState = {
+    allItems: [],
+    filteredResults: [],
+    selectedItem: null,
+    visibleStartIndex: 0,
+};
+const resultsReducer = (state, action) => {
+    switch (action.type) {
+        case 'INIT_ITEMS': {
+            const allItems = action.payload;
+            return {
+                ...state,
+                allItems,
+                filteredResults: allItems,
+                selectedItem: allItems[0] ?? null,
+            };
+        }
+        case 'FILTER_RESULTS': {
+            const query = action.query.toLowerCase();
+            const visibleStartIndex = 0;
+            if (query === '') {
+                const filteredResults = state.allItems;
+                return {
+                    ...state,
+                    filteredResults,
+                    visibleStartIndex,
+                    selectedItem: filteredResults[visibleStartIndex] ?? null,
+                };
+            }
+            const filteredResults = state.allItems.filter((result) => result.name.toLowerCase().includes(query.toLowerCase()));
+            return {
+                ...state,
+                filteredResults,
+                visibleStartIndex,
+                selectedItem: filteredResults[visibleStartIndex] ?? null,
+            };
+        }
+        case 'SELECT_RESULT': {
+            if (state.filteredResults.length === 0 || state.selectedItem === null) {
+                return state;
+            }
+            const selectedIndex = state.filteredResults
+                .map((r) => r.name)
+                .indexOf(state.selectedItem.name);
+            let newSelectedIndex = action.which === 'previous'
+                ? (selectedIndex - 1 + state.filteredResults.length) %
+                    state.filteredResults.length
+                : (selectedIndex + 1) % state.filteredResults.length;
+            const newSelectedName = state.filteredResults[newSelectedIndex] ?? null;
+            const start = Math.max(0, newSelectedIndex - MAX_VISIBLE_RESULTS + 1);
+            return {
+                ...state,
+                selectedItem: newSelectedName,
+                visibleStartIndex: start,
+            };
+        }
+        default:
+            return state;
+    }
+};
+export const Search = ({ width, choose }) => {
+    const [query, setQuery] = React.useState('');
+    const [{ filteredResults, visibleStartIndex, selectedItem }, dispatch] = React.useReducer(resultsReducer, initialState);
+    const config = useConfig();
+    const { needsRefresh, setNeedsRefresh } = useApplicationsCache();
+    const { goToView } = useView();
+    React.useEffect(() => {
+        const fetchItems = async () => {
+            try {
+                const items = await getItems({
+                    refresh: needsRefresh,
+                    config,
+                });
+                dispatch({ type: 'INIT_ITEMS', payload: items });
+            }
+            catch (error) {
+                goToView({ error: error });
+            }
+        };
+        fetchItems();
+        if (needsRefresh)
+            setNeedsRefresh(false);
+    }, [needsRefresh, config, setNeedsRefresh, goToView]);
+    useInput((_, key) => {
+        if (key.upArrow)
+            dispatch({ type: 'SELECT_RESULT', which: 'previous' });
+        if (key.downArrow)
+            dispatch({ type: 'SELECT_RESULT', which: 'next' });
+        if (key.escape)
+            filter('');
+    });
+    const filter = (query) => {
+        setQuery(query);
+        dispatch({ type: 'FILTER_RESULTS', query });
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Box, { borderStyle: "round", borderColor: config.theme.color },
+            React.createElement(TextInput, { value: query, onChange: filter, showCursor: true, placeholder: "Search...", onSubmit: () => {
+                    if (selectedItem)
+                        choose(selectedItem);
+                } })),
+        React.createElement(Text, null, filteredResults.length === 0 && 'No items...'),
+        React.createElement(Box, { borderStyle: filteredResults.length > 0 ? 'round' : undefined, borderColor: filteredResults.length > 0 ? 'grey' : undefined, flexDirection: "column" }, filteredResults
+            .slice(visibleStartIndex, visibleStartIndex + MAX_VISIBLE_RESULTS)
+            .map((item) => {
+            const selected = selectedItem?.name === item.name;
+            // 5 is an arbitrary number of some spaces around the item name, and some built-in padding.
+            let name = ` ${item.name}${' '.repeat(width > 0 ? width - 5 - item.name.length : 0)}`;
+            if (item.actionType === 'Show UI')
+                name = name.slice(0, -2) + '> ';
+            return (React.createElement(Box, { key: item.name },
+                React.createElement(Text, { backgroundColor: selected ? config.theme.color : undefined, bold: selected },
+                    React.createElement(Text, null, name))));
+        }))));
+};

package/SelectBox.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export declare const SelectBox: ({ items, maxVisibleResults, onChange, onSelect, width, }: {
+    items: string[];
+    maxVisibleResults?: number;
+    onChange?: (item: string) => void;
+    onSelect: (item: string) => void;
+    width?: number;
+}) => React.JSX.Element | null;

package/SelectBox.js

@@ -0,0 +1,48 @@
+import { Box, Text, useInput } from 'ink';
+import React from 'react';
+import { useConfig } from './config/ConfigContext.js';
+const noop = () => { };
+export const SelectBox = ({ items, maxVisibleResults = 10, onChange = noop, onSelect, width, }) => {
+    const [selectedIndex, setSelectedIndex] = React.useState(0);
+    const [startIndex, setStartIndex] = React.useState(0);
+    const config = useConfig();
+    const select = (which) => {
+        let newSelectedIndex = which === 'previous'
+            ? (selectedIndex - 1 + items.length) % items.length
+            : (selectedIndex + 1) % items.length;
+        setSelectedIndex(newSelectedIndex);
+        setStartIndex(Math.max(0, newSelectedIndex - maxVisibleResults + 1));
+        return newSelectedIndex;
+    };
+    useInput((_, key) => {
+        if (items.length === 0 || !items[selectedIndex])
+            return;
+        if (key.return) {
+            onSelect(items[selectedIndex]);
+        }
+        if (key.upArrow) {
+            const newSelectedIndex = select('previous');
+            if (items[newSelectedIndex])
+                onChange(items[newSelectedIndex]);
+        }
+        if (key.downArrow) {
+            const newSelectedIndex = select('next');
+            if (items[newSelectedIndex])
+                onChange(items[newSelectedIndex]);
+        }
+    });
+    if (items.length === 0)
+        return null;
+    // 4 is some padding, and spaces at the beginning and end of the item
+    // const width = items.reduce((max, item) => Math.max(max, item.length), 0) + 4
+    if (!width) {
+        width = items.reduce((max, item) => Math.max(max, item.length), 0) + 4;
+    }
+    return (React.createElement(Box, { borderStyle: "round", borderColor: "grey", flexDirection: "column", width: width }, items.slice(startIndex, startIndex + maxVisibleResults).map((item) => {
+        const selected = item === items[selectedIndex];
+        // 3 is an arbitrary number of some spaces around the item name, and some built-in padding.
+        let name = ` ${item}${' '.repeat(width > 0 ? width - 3 - item.length : 0)}`;
+        return (React.createElement(Box, { key: item },
+            React.createElement(Text, { backgroundColor: selected ? config.theme.color : undefined, bold: selected }, name)));
+    })));
+};

package/ViewContext.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { ReactItem } from './items/types.js';
+type ErrorView = {
+    error: Error;
+};
+type View = 'search' | 'loading' | ErrorView | ReactItem;
+type ViewContextType = {
+    view: View;
+    goToView: (view: View) => void;
+};
+declare function ViewProvider({ children }: React.PropsWithChildren): React.JSX.Element;
+declare function useView(): ViewContextType;
+export { ViewProvider, useView };

package/ViewContext.js

@@ -0,0 +1,17 @@
+import React from 'react';
+const ViewContext = React.createContext(null);
+function ViewProvider({ children }) {
+    const [view, setView] = React.useState('search');
+    const goToView = React.useCallback((view) => {
+        setView(view);
+    }, []);
+    const value = { view, goToView };
+    return React.createElement(ViewContext.Provider, { value: value }, children);
+}
+function useView() {
+    const context = React.useContext(ViewContext);
+    if (!context)
+        throw new Error('useView must be used within a ViewProvider');
+    return context;
+}
+export { ViewProvider, useView };

package/app.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function App(): React.JSX.Element;

package/app.js

@@ -0,0 +1,53 @@
+import React from 'react';
+import { Box, measureElement, Text } from 'ink';
+import { Search } from './Search.js';
+import { Component } from './Component.js';
+import { useView } from './ViewContext.js';
+import { Error } from './Error.js';
+import { Footer } from './Footer.js';
+export default function App() {
+    const { view, goToView } = useView();
+    // The searchKey is used to force a re-render of the Search component
+    const [searchKey, setSearchKey] = React.useState(0);
+    const [containerWidth, setContainerWidth] = React.useState(0);
+    const containerRef = React.useRef(null);
+    React.useEffect(() => {
+        if (!containerRef.current)
+            return;
+        const { width } = measureElement(containerRef.current);
+        setContainerWidth(width);
+    }, []);
+    React.useEffect(() => {
+        if (view === 'loading') {
+            setTimeout(() => {
+                renderSearch();
+            }, 1500);
+        }
+    }, [view]);
+    const renderSearch = () => {
+        setSearchKey((prev) => prev + 1);
+        goToView('search');
+    };
+    const choose = async (item) => {
+        if (item.actionType === 'Show UI') {
+            try {
+                goToView(item);
+            }
+            catch (error) {
+                goToView({ error: error });
+            }
+        }
+        else if (item.actionType === 'Fire and forget') {
+            try {
+                await item.action();
+                goToView('loading');
+            }
+            catch (error) {
+                goToView({ error: error });
+            }
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "grey", width: "100%", minHeight: 20, ref: containerRef }, view === 'search' ? (React.createElement(Search, { key: searchKey, width: containerWidth, choose: choose })) : view === 'loading' ? (React.createElement(Text, null, "\\n\\n\\n\\n\\n\\n\\n\\nLoading...")) : 'error' in view ? (React.createElement(Error, { error: view.error })) : 'actionType' in view && view.actionType === 'Show UI' ? (React.createElement(Component, { item: view })) : null),
+        React.createElement(Footer, null)));
+}

package/apps/ApplicationsCacheContext.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+type ApplicationsCacheContextType = {
+    needsRefresh: boolean;
+    setNeedsRefresh: (needsRefresh: boolean) => void;
+};
+declare function ApplicationsCacheProvider({ children }: React.PropsWithChildren): React.JSX.Element;
+declare function useApplicationsCache(): ApplicationsCacheContextType;
+export { ApplicationsCacheProvider, useApplicationsCache };

package/apps/ApplicationsCacheContext.js

@@ -0,0 +1,14 @@
+import React from 'react';
+const ApplicationsCache = React.createContext(null);
+function ApplicationsCacheProvider({ children }) {
+    const [needsRefresh, setNeedsRefresh] = React.useState(false);
+    const value = { needsRefresh, setNeedsRefresh };
+    return (React.createElement(ApplicationsCache.Provider, { value: value }, children));
+}
+function useApplicationsCache() {
+    const context = React.useContext(ApplicationsCache);
+    if (!context)
+        throw new Error('useApplicationsCache must be used within a ApplicationsCacheProvider');
+    return context;
+}
+export { ApplicationsCacheProvider, useApplicationsCache };

package/apps/RefreshApps.d.ts

@@ -0,0 +1 @@
+export declare const RefreshApps: () => null;

package/apps/RefreshApps.js

@@ -0,0 +1,13 @@
+import React from 'react';
+import { useApplicationsCache } from './ApplicationsCacheContext.js';
+import { useView } from '../ViewContext.js';
+// Indicates to the app cache that it needs to refresh the apps.
+export const RefreshApps = () => {
+    const { setNeedsRefresh } = useApplicationsCache();
+    const { goToView } = useView();
+    React.useEffect(() => {
+        setNeedsRefresh(true);
+        goToView('search');
+    }, []);
+    return null;
+};

package/config/ConfigContext.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { Config } from './types.js';
+type ConfigContextType = Config;
+declare const Config: React.Context<Config | null>;
+type Props = {
+    children: React.ReactNode;
+    config: ConfigContextType;
+};
+declare function ConfigProvider({ children, config }: Props): React.JSX.Element;
+declare function useConfig(): Config;
+export { ConfigProvider, useConfig };

package/config/ConfigContext.js

@@ -0,0 +1,12 @@
+import React from 'react';
+const Config = React.createContext(null);
+function ConfigProvider({ children, config }) {
+    return React.createElement(Config.Provider, { value: config }, children);
+}
+function useConfig() {
+    const context = React.useContext(Config);
+    if (!context)
+        throw new Error('useConfig must be used within a ConfigProvider');
+    return context;
+}
+export { ConfigProvider, useConfig };

package/config/parseAndValidate.d.ts

@@ -0,0 +1,2 @@
+import { Config, UserConfig } from './types.js';
+export declare const parseAndValidate: (userConfig?: UserConfig) => Config;

package/config/parseAndValidate.js

@@ -0,0 +1,51 @@
+import { openBookmark } from '../GoogleChrome.js';
+const defaultConfig = {
+    excludeApps: [],
+    favoriteItems: [],
+    chromeProfiles: false,
+    items: [],
+    theme: {
+        color: 'green',
+    },
+};
+export const parseAndValidate = (userConfig) => {
+    if (!userConfig)
+        return defaultConfig;
+    const chromeProfiles = userConfig.chromeProfiles || false;
+    const items = userConfig.items
+        ?.map((userItem) => {
+        const actionString = userItem.action.toString();
+        // A function that returns JSX is considered a UI action
+        if (actionString.startsWith('() => React.createElement('))
+            return {
+                name: userItem.name,
+                action: userItem.action,
+                actionType: 'Show UI',
+            };
+        // A function that returns a promise is considered a fire-and-forget action
+        if (actionString.startsWith('() => Promise.resolve('))
+            return {
+                name: userItem.name,
+                action: userItem.action,
+                actionType: 'Fire and forget',
+            };
+        // An object is considered a bookmark object, which is converted to a fire-and-forget actions
+        if (actionString === '[object Object]')
+            return {
+                name: userItem.name,
+                action: () => openBookmark(userItem.action),
+                actionType: 'Fire and forget',
+            };
+        return null;
+    })
+        .filter((item) => item !== null);
+    return {
+        excludeApps: userConfig.excludeApps || [],
+        favoriteItems: userConfig.favoriteItems || [],
+        chromeProfiles,
+        items,
+        theme: {
+            color: userConfig.theme?.color || defaultConfig.theme.color,
+        },
+    };
+};

package/config/types.d.ts

@@ -0,0 +1,26 @@
+import { BookmarkAction, FunctionAction, Item, ReactAction } from '../items/types.js';
+export type UserItem = {
+    name: string;
+    action: FunctionAction | ReactAction | BookmarkAction;
+};
+type FriendlyName = string;
+type ChromeProfile = string;
+export type ChromeProfiles = Record<FriendlyName, ChromeProfile> | false;
+export type Theme = {
+    color: 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'cyan' | 'magenta' | 'white' | 'gray' | 'grey' | 'blackBright' | 'redBright' | 'greenBright' | 'yellowBright' | 'blueBright' | 'cyanBright' | 'magentaBright' | 'whiteBright';
+};
+export type UserConfig = {
+    theme?: Theme;
+    chromeProfiles?: ChromeProfiles;
+    excludeApps?: string[];
+    favoriteItems?: string[];
+    items?: UserItem[];
+};
+export type Config = {
+    theme: Theme;
+    chromeProfiles: ChromeProfiles;
+    excludeApps: string[];
+    favoriteItems: string[];
+    items: Item[];
+};
+export {};

package/config/types.js

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

package/debugging/useExitAppRightAway.d.ts

@@ -0,0 +1 @@
+export declare const useExitAppRightAway: () => void;

package/debugging/useExitAppRightAway.js

@@ -0,0 +1,9 @@
+import { useApp } from 'ink';
+import { useEffect } from 'react';
+// Helper for exiting the app right away, for debugging purposes, for example when debugging styling issues.
+export const useExitAppRightAway = () => {
+    const { exit } = useApp();
+    useEffect(() => {
+        exit();
+    }, []);
+};

package/helpers/EscapeBackToSearch.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    title: string;
+    children: React.ReactNode;
+};
+export declare const EscapeBackToSearch: ({ title, children }: Props) => React.JSX.Element;
+export {};

package/helpers/EscapeBackToSearch.js

@@ -0,0 +1,20 @@
+import React from 'react';
+import { useInput } from 'ink';
+import { useView } from '../ViewContext.js';
+import { Box, Text } from 'ink';
+import { useConfig } from '../config/ConfigContext.js';
+export const EscapeBackToSearch = ({ title, children }) => {
+    const { goToView } = useView();
+    const config = useConfig();
+    useInput((_, key) => {
+        if (key.escape)
+            goToView('search');
+    });
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: config.theme.color },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: config.theme.color }, title)),
+            children),
+        React.createElement(Box, { borderStyle: "round", borderColor: "grey" },
+            React.createElement(Text, null, "ESC = back"))));
+};

package/helpers/spawnProcess.d.ts

@@ -0,0 +1 @@
+export declare const spawnProcess: (command: string, args: string[]) => Promise<Buffer>;

package/helpers/spawnProcess.js

@@ -0,0 +1,20 @@
+import childProcess from 'child_process';
+export const spawnProcess = (command, args) => {
+    return new Promise((resolve, reject) => {
+        const process = childProcess.spawn(command, args);
+        const output = [];
+        process.stdout?.on('data', (data) => output.push(data));
+        process.stderr?.on('data', (data) => output.push(data));
+        process.on('error', (error) => {
+            reject(new Error(error.message));
+        });
+        process.on('close', (code) => {
+            if (code === 0) {
+                resolve(Buffer.concat(output));
+            }
+            else {
+                reject(new Error(`The following command failed with exit code ${code}:\n\n${command} ${args.join(' ')}`));
+            }
+        });
+    });
+};

package/helpers/tryCatch.d.ts

@@ -0,0 +1,9 @@
+type Result<T> = {
+    value: T;
+    error: null;
+} | {
+    value: null;
+    error: Error;
+};
+export declare function tryCatch<T>(fn: () => T): Result<T>;
+export {};

package/helpers/tryCatch.js

@@ -0,0 +1,11 @@
+export function tryCatch(fn) {
+    try {
+        return { value: fn(), error: null };
+    }
+    catch (error) {
+        return {
+            value: null,
+            error: error instanceof Error ? error : new Error(String(error)),
+        };
+    }
+}

package/items/items.d.ts

@@ -0,0 +1,6 @@
+import { Item } from './types.js';
+import { Config } from '../config/types.js';
+export declare const getItems: ({ refresh, config, }: {
+    refresh: boolean;
+    config: Config;
+}) => Promise<Item[]>;

package/items/items.js

@@ -0,0 +1,107 @@
+import React from 'react';
+import { RefreshApps } from '../apps/RefreshApps.js';
+import { spawnProcess } from '../helpers/spawnProcess.js';
+// Fetch installed apps using the `ls` command
+const getApplications = async (excludeApps) => {
+    const data = await spawnProcess('ls', ['/Applications']);
+    const apps = data
+        .toString()
+        .split('\n')
+        .map((app) => app.replace('.app', '').trim())
+        .filter((app) => app !== '' && !excludeApps.includes(app));
+    const items = apps.map((app) => ({
+        name: app,
+        action: async () => {
+            await spawnProcess('open', ['-a', app]);
+        },
+        actionType: 'Fire and forget',
+    }));
+    return items;
+};
+// Fetch installed preference panes using the `find` command
+const getPrefPanes = async () => {
+    // Somehow this command does not return anything...
+    // const data = await spawnProcess('find', [
+    //   '/System/Library/PreferencePanes',
+    //   '-name',
+    //   '"*.prefPane"',
+    // ])
+    // ScriptKit lists the following applications:
+    // const APP_DIR = '/Applications'
+    // const UTILITIES_DIR = `${APP_DIR}/Utilities`
+    // const SYSTEM_UTILITIES_DIR = '/System/Applications/Utilities'
+    // const CHROME_APPS_DIR = home('Applications', 'Chrome Apps.localized')
+    // as long as the command does not work, here is a hardcoded list with the most common prefPanes
+    const data = `
+  /System/Library/PreferencePanes/Bluetooth.prefPane
+  /System/Library/PreferencePanes/Network.prefPane
+  /System/Library/PreferencePanes/Battery.prefPane
+  /System/Library/PreferencePanes/Security.prefPane
+  /System/Library/PreferencePanes/Dock.prefPane
+  /System/Library/PreferencePanes/Sound.prefPane
+  /System/Library/PreferencePanes/Appearance.prefPane
+  /System/Library/PreferencePanes/Displays.prefPane
+  /System/Library/PreferencePanes/Notifications.prefPane
+  /System/Library/PreferencePanes/Accounts.prefPane
+  /System/Library/PreferencePanes/Trackpad.prefPane
+  /System/Library/PreferencePanes/DateAndTime.prefPane
+  /System/Library/PreferencePanes/EnergySaverPref.prefPane
+  /System/Library/PreferencePanes/Keyboard.prefPane
+  /System/Library/PreferencePanes/Spotlight.prefPane
+  /System/Library/PreferencePanes/AppleIDPrefPane.prefPane
+  /System/Library/PreferencePanes/SharingPref.prefPane
+  /System/Library/PreferencePanes/Profiles.prefPane
+  /System/Library/PreferencePanes/SoftwareUpdate.prefPane
+  /System/Library/PreferencePanes/Mouse.prefPane
+  `;
+    const prefPanes = data
+        .toString()
+        .split('\n')
+        .map((prefPane) => prefPane.trim())
+        .filter((prefPane) => prefPane !== '');
+    const items = prefPanes.map((prefPane) => ({
+        name: prefPane.split('/').pop()?.replace('.prefPane', '').trim() || '',
+        action: async () => {
+            await spawnProcess('open', [prefPane]);
+        },
+        actionType: 'Fire and forget',
+    }));
+    return items;
+};
+const getCachableItems = async (excludeApps) => {
+    const [apps, prefPanes] = await Promise.all([
+        getApplications(excludeApps),
+        getPrefPanes(),
+    ]);
+    return [...apps, ...prefPanes];
+};
+const getDefaultUIs = () => [
+    {
+        name: 'Refresh apps',
+        action: () => React.createElement(RefreshApps, null),
+        actionType: 'Show UI',
+    },
+];
+const getDefaultBookmarks = () => [];
+// Main function to get items, with caching support for apps only
+export const getItems = (() => {
+    let cachedItems = null;
+    return async ({ refresh = false, config, }) => {
+        if (!cachedItems || refresh)
+            cachedItems = await getCachableItems(config.excludeApps);
+        const defaultItems = [
+            ...getDefaultUIs(),
+            ...getDefaultBookmarks(),
+        ];
+        const items = [...cachedItems, ...defaultItems, ...config.items];
+        return items.sort((a, b) => {
+            const isAFavorite = config.favoriteItems.includes(a.name);
+            const isBFavorite = config.favoriteItems.includes(b.name);
+            if (isAFavorite && !isBFavorite)
+                return -1;
+            if (!isAFavorite && isBFavorite)
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+    };
+})();

package/items/types.d.ts

@@ -0,0 +1,23 @@
+type BaseItem<T extends string> = {
+    name: string;
+    actionType: T;
+};
+export type FunctionAction = () => Promise<void>;
+export type FunctionItem = BaseItem<'Fire and forget'> & {
+    action: FunctionAction;
+};
+export type ReactAction = () => JSX.Element;
+export type ReactItem = BaseItem<'Show UI'> & {
+    action: ReactAction;
+};
+export type BookmarkInfo = {
+    browser?: string;
+    profile?: string;
+    url: string;
+};
+export type BookmarkAction = BookmarkInfo;
+export type BookmarkItem = BaseItem<'Open URL'> & {
+    action: BookmarkAction;
+};
+export type Item = FunctionItem | ReactItem | BookmarkItem;
+export {};

package/items/types.js

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

package/package.json

@@ -1,35 +1,10 @@
 {
   "name": "conzo",
-  "version": "0.0.8",
-  "license": "MIT",
-  "main": "dist/Conzo.js",
+  "version": "0.0.10",
   "type": "module",
-  "engines": {
-    "node": ">=16"
-  },
-  "scripts": {
-    "build": "rm -rf dist && tsc && tsc-alias && cp package.json README.md ./dist"
-  },
-  "files": [
-    "dist"
-  ],
-  "dependencies": {
-    "ink": "^5.0.1",
-    "ink-text-input": "^6.0.0",
-    "meow": "^13.2.0",
-    "react": "^18.3.1",
-    "react-error-boundary": "^4.1.2"
-  },
-  "devDependencies": {
-    "@sindresorhus/tsconfig": "^6.0.0",
-    "@types/react": "^18.3.12",
-    "chalk": "^5.3.0",
-    "eslint-plugin-react": "^7.37.2",
-    "eslint-plugin-react-hooks": "^5.0.0",
-    "prettier": "^3.3.3",
-    "react-devtools-core": "^4.28.5",
-    "ts-node": "^10.9.2",
-    "tsc-alias": "^1.8.10",
-    "typescript": "^5.6.3"
-  }
+  "main": "./Conzo.js",
+  "files": ["**/*"],
+  "dependencies": {"ink":"^5.0.1","ink-text-input":"^6.0.0","meow":"^13.2.0","react":"^18.3.1","react-error-boundary":"^4.1.2"},
+  "author": "Bouwe",
+  "license": "MIT"
 }