planning.txt

HomePage: 
    Hero section:
        Title + picture of LM:
            - Video starts a search that results in a LaunchMenu note and pauses here:
                Note / Video editing describes:
                    - Top bar is the search and input field, where queries can be entered and data can be changed
                    - Left section is the menu of items that match the query
                    - This section is the content section, showing data associated to the selected item
            - Next to video:
                - download button
                - Developing applets?
        Quick selling points below:
            - What is LaunchMenu
                - Free and Open source
                - Multi-platform
                - BOLD: A framework that other utilities (applets) can live in:
                    - link to planned utils or list some
            - (Why) Utilities at your fingertips:
                - Always running
                - Easy to use blabla
                - Keyboard first solution
            - Applet customisation
                - Installable plugins 
                - Extensive settings
                - bla bla

    Features area:
        - LaunchMenu is actively developed:
            Because of this, some features are partially supported, but not fully there yet, we will use this legend in the features:
                - S (Green): Supported
                - C (amber): Coming soon
                - L (red) : Long term 
                (These symbols will have tooltips in different sections with more nuanced data)
        - Full keyboard navigation:
            Use keyboard controls to:
                - S: Select items
                - S: Execute item actions
                - S: Step in and out of menus 
                - S: Do everything else in LM!
                - S: Customize any controls
                - C: Native VIM keys mode
        - Search anywhere: 
            - S: Any menu in LM is searchable by default.
            - S: Searches look through the selected menu and all sub-menus
            - S: Searches can use patterns to automatically filter results
            - S: By default fuzzy search is used
            - L: All searches are tracked and prioritized intelligently
        - Context menu
            - S: Items can contain multiple actions
            - S: A context menu can be opened to show these actions
            - S: Search context menus for quicker execution 
            - S: Context menus can contain sub-menus
            - S: The path shows where you are in the application
        - Multi-select
            - S: Multiple items can be selected and executed at once
            - S: A shared context menu can be opened for these items
        - Customize:
            - S: Easy settings that can be searched and altered
            - S: Many aspects of LaunchMenu can personalized
            - S: Controls can be customized
            - S: All applets can be customized
            - C: Import + Export settings.
            - C: Official and 3rd party applets can be browsed and installed:
                - Tooltip: Infrastructure complete, UI required
            - C: Themes can be customised:
                - Tooltip: Infrastructure complete, UI required
        - Undo Redo facility
            - C: LaunchMenu allows impactful actions to be undone and redone.
                - Tooltip: Infrastructure complete, UI Required
            - L: You can see/visualize undo-redo history
                - Tooltip: Infrastructure complete, UI Required, low priority
        
    Download Area:
        - S: Windows
        - C: Mac
        - L: Linux


    Applets Area:
        - S: Dictionary
        - S: Notes
        - C: Calculator
        - L: Pornhub?: https://www.npmjs.com/package/@justalk/pornhub-api

    Recommendations:
        - Super cool software! - Tar van Krieken, lead developer of LM
        - Exactly what I wanted! - Sancarn, product consultant of LM
        - Cool shit. - Bram Hoven, LM contributor

Developers page:
    Hero section: 
        Hero:
            ```tsx            
            export const info = {
                name: "HelloWorld",
                description: "A minimal example applet",
                version: "0.0.0",
                icon: <MyIcon />,
            };

            export const settings = createSettings({
                version: "0.0.0",
                settings: () => createSettingsFolder({ ...info, children: {
                    name: createStringSetting({name: "User name", init: "Bob"}),
                }}),
            });

            const items = [
                createStandardMenuItem({
                    name: "Hello world",
                    onExecute: ({context}) => 
                        alert(`Hello ${context.settings.get(settings).name.get()}!`)
                }),
            ];

            export default declare({
                info,
                settings,
                async search: (query, hook) => ({ children: searchAction.get(items) })
            });
            ```
            with 3 pictures besides the code, highlighting the effect of the first, second and third sections
            
        Quick selling points:
            - Super flexible
                - If something is lacking, build your own from scratch, it can still be used as a LM applet. We won't stop you!
            - Environment:
                - Common web technologies:  
                    - Typescript
                    - React
                    - Electron
                - Cross platform (Large potential audience)
            - Common tasks simplified:
                - Themed components
                - Settings configuration
                - Undo/redo
                - Menus / Searching etc.
    Features:
        - Ease of developement
            - Composability of LaunchMenu
            - Developer Environment:
                - TypeScript and TSDoc (intellisense)
                - Automatic applet reload (disclaimer to what degree it works)
                - Modules can be published to NPM
            - We value your input to fix stuff
        - Menu Items
            - Mnemonics
        - Search system
        - Actions system:            
            ```
            import {createContextAction, selectExecuteHandler, singlePromptExecuteHandler} from "@launchmenu/core";

            type ITaskPriority = "high" | "medium" | "low";
            export const setTaskPriority = createContextAction({
                name: "Set priority level",
                contextItem: { priority: Priority.MEDIUM }, //Not to be confused with ITaskPriority
                core: (fields: Field<ITaskPriority>[]) => {
                    const getExecuteBinding = () => 
                        singlePromptExecuteHandler.createBinding(
                            fields, 
                            field=>selectExecuteHandler.createBinding({
                                field,
                                options: ["low", "medium", "high"],
                                createOptionView: level =>
                                    createStandardMenuItem({ name: level }),
                            })
                        );

                    return {
                        // Return the bindings for executing the action in the menu
                        actionBindings: getExecuteBindings,
                        // As well as some result for programmatic access for extension
                        result: { getExecuteBindings },
                    };
                },
            });
            ```
            ```          
            import {createStandardMenuItem} from "@launchmenu/core";
            function createTaskMenuItem({name}: {name: string}) {
                const level = new Field("medium");
                return createStandardMenuItem({
                    name,
                    description: hook => level.get(hook)
                });
            }

            const items = [
                createTaskMenuItem({name: "Meet Alice"}),
                createTaskMenuItem({name: "Make pancakes"}),
                createTaskMenuItem({name: "Free Hat"})
            ]
            ```

            - A powerful system to create actions that can be shown in the context menu
            - Actions support selection of multiple items, and performing of shared functionality
            - Ability to bundle different behavior depending item type into a single action in the context menu
            - Can add new behavior to existing actions, without modifying code of existing actions
            - Most of our actions have undo/redo for free
        - Settings            
        - Undo/redo system

    Community:

    References:




Resources:
    Alternatives:
        https://www.alfredapp.com/
        https://obdev.at/products/launchbar/index.html
        https://keypirinha.com/
        https://www.listary.com/
    Applications:
        https://code.visualstudio.com/
        https://www.landingfolio.com/
        https://strapi.io/
    Langs:
        https://www.autohotkey.com/
        https://www.python.org/
        https://www.rust-lang.org/
        https://processing.org/
        https://www.ruby-lang.org/en/
        https://crystal-lang.org/
        https://dotnet.microsoft.com/?utm_source=developermscom
    Libs:
        https://reactjs.org/
        https://angular.io/
        https://ant.design/
        https://material-ui.com/
        https://developer.microsoft.com/en-us/fluentui#/
    Products: 
        https://www.dji.com/nl/dji-fpv

in-depth:
    - [x] applet format/declare
    - base:
        - [x] LaunchMenu
        - [x] Session
        - [x] IOContext
    - UI:
        - [x] menu items
        - [x] UILayer (include views)
        - [x] Menu (+categories)
        - [x] Field
        - [x] Content
    - Interaction
        - [x] Actions basics
        - [x] Common actions
        - [x] search system
        - [x] Undo/redo
        - [x] Key events (+shortcuts)
    - [x] Settings