dappbooster 2.0.1 → 3.0.0

package/dist/app.d.ts

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

package/dist/app.js

@@ -0,0 +1,49 @@
+import { Box } from 'ink';
+import React, { useState, useMemo, useCallback } from 'react';
+import MainTitle from './import/components/MainTitle.js';
+import CloneRepo from './import/components/steps/CloneRepo/CloneRepo.js';
+import FileCleanup from './import/components/steps/FileCleanup.js';
+import Install from './import/components/steps/Install/Install.js';
+import InstallationMode from './import/components/steps/InstallationMode.js';
+import OptionalPackages from './import/components/steps/OptionalPackages.js';
+import PostInstall from './import/components/steps/PostInstall.js';
+import ProjectName from './import/components/steps/ProjectName.js';
+import { canShowStep } from './import/utils/utils.js';
+const App = () => {
+    const [projectName, setProjectName] = useState('');
+    const [currentStep, setCurrentStep] = useState(1);
+    const [setupType, setSetupType] = useState();
+    const [selectedFeatures, setSelectedFeatures] = useState();
+    const finishStep = useCallback(() => setCurrentStep(currentStep + 1), [currentStep]);
+    const onSelectSetupType = useCallback((item) => setSetupType(item), []);
+    const onSelectSelectedFeatures = useCallback((selectedItems) => setSelectedFeatures([...selectedItems]), []);
+    const steps = useMemo(() => [
+        React.createElement(ProjectName, { onCompletion: finishStep, onSubmit: setProjectName, projectName: projectName, key: 1 }),
+        React.createElement(CloneRepo, { onCompletion: finishStep, projectName: projectName, key: 2 }),
+        React.createElement(InstallationMode, { onCompletion: finishStep, onSelect: onSelectSetupType, key: 3 }),
+        React.createElement(OptionalPackages, { installation: setupType?.value, onCompletion: finishStep, onSubmit: onSelectSelectedFeatures, key: 4 }),
+        React.createElement(Install, { installationConfig: {
+                installationType: setupType?.value,
+                selectedFeatures: selectedFeatures,
+            }, onCompletion: finishStep, projectName: projectName, key: 5 }),
+        React.createElement(FileCleanup, { installationConfig: {
+                installationType: setupType?.value,
+                selectedFeatures: selectedFeatures,
+            }, onCompletion: finishStep, projectName: projectName, key: 6 }),
+        React.createElement(PostInstall, { projectName: projectName, installationConfig: {
+                installationType: setupType?.value,
+                selectedFeatures: selectedFeatures,
+            }, key: 7 }),
+    ], [
+        finishStep,
+        onSelectSelectedFeatures,
+        setupType?.value,
+        selectedFeatures,
+        onSelectSetupType,
+        projectName,
+    ]);
+    return (React.createElement(Box, { flexDirection: 'column', rowGap: 1, width: 80 },
+        React.createElement(MainTitle, null),
+        steps.map((item, index) => canShowStep(currentStep, index + 1) && item)));
+};
+export default App;

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { render } from 'ink';
+import React from 'react';
+import App from './app.js';
+console.clear();
+render(React.createElement(App, null));

package/dist/import/components/Ask.d.ts

@@ -0,0 +1,11 @@
+import { type FC } from 'react';
+interface Props {
+    answer?: string;
+    errorMessage?: string;
+    onSubmit: (value: string) => void;
+    question: string;
+    tip?: string;
+    placeholder?: string;
+}
+declare const Ask: FC<Props>;
+export default Ask;

package/dist/import/components/Ask.js

@@ -0,0 +1,18 @@
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+import React, { useMemo, useState } from 'react';
+import { isAnswerConfirmed } from '../utils/utils.js';
+const Ask = ({ question, onSubmit, answer, tip, errorMessage, placeholder }) => {
+    const [input, setInput] = useState('');
+    const answered = useMemo(() => isAnswerConfirmed(answer, errorMessage), [answer, errorMessage]);
+    return (React.createElement(Box, { flexDirection: 'column', rowGap: 1 },
+        React.createElement(Box, { flexDirection: 'column' },
+            React.createElement(Box, null,
+                React.createElement(Text, { color: 'whiteBright' },
+                    question,
+                    ": "),
+                answered ? (React.createElement(Text, { bold: true, color: 'green' }, answer)) : (React.createElement(TextInput, { onChange: setInput, onSubmit: onSubmit, placeholder: placeholder, value: input }))),
+            tip && React.createElement(Text, { color: 'gray' }, tip)),
+        errorMessage && (React.createElement(Text, { bold: true, color: 'red' }, errorMessage))));
+};
+export default Ask;

package/dist/import/components/Divider.d.ts

@@ -0,0 +1,5 @@
+import { type FC } from 'react';
+declare const Divider: FC<{
+    title: string;
+}>;
+export default Divider;

package/dist/import/components/Divider.js

@@ -0,0 +1,4 @@
+import BaseDivider from 'ink-divider';
+import React from 'react';
+const Divider = ({ title }) => (React.createElement(BaseDivider, { titlePadding: 2, titleColor: 'whiteBright', title: title }));
+export default Divider;

package/dist/import/components/MainTitle.d.ts

@@ -0,0 +1,3 @@
+import { type FC } from 'react';
+declare const MainTitle: FC;
+export default MainTitle;

package/dist/import/components/MainTitle.js

@@ -0,0 +1,6 @@
+import BigText from 'ink-big-text';
+import Gradient from 'ink-gradient';
+import React from 'react';
+const MainTitle = () => (React.createElement(Gradient, { colors: ['#ff438c', '#bb1d79', '#8b46a4', '#6a2581'] },
+    React.createElement(BigText, { lineHeight: 1, font: 'chrome', text: "dAppBooster" })));
+export default MainTitle;

package/dist/import/components/Multiselect/MultiSelect.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import CheckBox from './components/Checkbox.js';
+import Indicator from './components/Indicator.js';
+import ItemComponent from './components/Item.js';
+type Item<T> = {
+    label: string;
+    value: T;
+    key?: string | number;
+};
+type MultiSelectProps<T> = {
+    items: Item<T>[];
+    defaultSelected?: Item<T>[];
+    focus?: boolean;
+    initialIndex?: number;
+    indicatorComponent?: React.FC<{
+        isHighlighted: boolean;
+    }>;
+    checkboxComponent?: React.FC<{
+        isSelected: boolean;
+    }>;
+    itemComponent?: React.FC<{
+        isHighlighted: boolean;
+        label: string;
+    }>;
+    limit?: number | null;
+    onSelect?: (selectedItem: Item<T>) => void;
+    onUnselect?: (unselectedItem: Item<T>) => void;
+    onSubmit?: (selectedItems: Item<T>[]) => void;
+    onHighlight?: (highlightedItem: Item<T>) => void;
+};
+declare const MultiSelect: <T>({ items, defaultSelected, focus, initialIndex, indicatorComponent, checkboxComponent, itemComponent, limit, onSelect, onUnselect, onSubmit, onHighlight, }: MultiSelectProps<T>) => React.JSX.Element;
+export default MultiSelect;
+export { Indicator, ItemComponent, CheckBox, type Item };

package/dist/import/components/Multiselect/MultiSelect.js

@@ -0,0 +1,68 @@
+import { Box, useInput } from 'ink';
+import React, { useCallback, useState } from 'react';
+import CheckBox from './components/Checkbox.js';
+import Indicator from './components/Indicator.js';
+import ItemComponent from './components/Item.js';
+const MultiSelect = ({ items = [], defaultSelected = [], focus = true, initialIndex = 0, indicatorComponent = Indicator, checkboxComponent = CheckBox, itemComponent = ItemComponent, limit = null, onSelect = () => { }, onUnselect = () => { }, onSubmit = () => { }, onHighlight = () => { }, }) => {
+    const [highlightedIndex, setHighlightedIndex] = useState(initialIndex);
+    const [selectedItems, setSelectedItems] = useState(defaultSelected);
+    const hasLimit = limit !== null && limit < items.length;
+    const slicedItems = hasLimit ? items.slice(0, limit) : items;
+    const includesItems = useCallback((item, selectedItems) => {
+        return (selectedItems.filter((selectedItem) => selectedItem.value === item.value && selectedItem.label === item.label).length > 0);
+    }, []);
+    const handleSelect = useCallback((item) => {
+        if (includesItems(item, selectedItems)) {
+            const newSelectedItems = selectedItems.filter((selectedItem) => selectedItem.value !== item.value && selectedItem.label !== item.label);
+            setSelectedItems(newSelectedItems);
+            onUnselect(item);
+        }
+        else {
+            const newSelectedItems = [...selectedItems, item];
+            setSelectedItems(newSelectedItems);
+            onSelect(item);
+        }
+    }, [selectedItems, onSelect, onUnselect, includesItems]);
+    const handleSubmit = useCallback(() => {
+        onSubmit(selectedItems);
+    }, [selectedItems, onSubmit]);
+    useInput(useCallback((input, key) => {
+        if (key.upArrow) {
+            setHighlightedIndex((prevIndex) => {
+                const index = prevIndex === 0 ? slicedItems.length - 1 : prevIndex - 1;
+                // biome-ignore lint/style/noNonNullAssertion: <explanation>
+                onHighlight(slicedItems[index]);
+                return index;
+            });
+        }
+        else if (key.downArrow) {
+            setHighlightedIndex((prevIndex) => {
+                const index = prevIndex === slicedItems.length - 1 ? 0 : prevIndex + 1;
+                // biome-ignore lint/style/noNonNullAssertion: <explanation>
+                onHighlight(slicedItems[index]);
+                return index;
+            });
+        }
+        else if (key.return) {
+            handleSubmit();
+        }
+        else if (input === ' ') {
+            // biome-ignore lint/style/noNonNullAssertion: <explanation>
+            handleSelect(slicedItems[highlightedIndex]);
+        }
+    }, [onHighlight, handleSelect, handleSubmit, slicedItems, highlightedIndex]), { isActive: focus });
+    return (React.createElement(Box, { flexDirection: "column" }, slicedItems.map((item, index) => {
+        const key = item.key || item.label;
+        const isHighlighted = index === highlightedIndex;
+        const isSelected = includesItems(item, selectedItems);
+        return (React.createElement(Box, { key: key },
+            React.createElement(indicatorComponent, { isHighlighted }),
+            React.createElement(checkboxComponent, { isSelected }),
+            React.createElement(itemComponent, {
+                ...item,
+                isHighlighted,
+            })));
+    })));
+};
+export default MultiSelect;
+export { Indicator, ItemComponent, CheckBox };

package/dist/import/components/Multiselect/components/Checkbox.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+type CheckBoxProps = {
+    isSelected: boolean;
+};
+declare const CheckBox: ({ isSelected }: CheckBoxProps) => React.JSX.Element;
+export default CheckBox;

package/dist/import/components/Multiselect/components/Checkbox.js

@@ -0,0 +1,6 @@
+import figures from 'figures';
+import { Box, Text } from 'ink';
+import React from 'react';
+const CheckBox = ({ isSelected = false }) => (React.createElement(Box, { marginRight: 1 },
+    React.createElement(Text, { color: isSelected ? 'green' : 'white' }, isSelected ? figures.circleFilled : figures.circle)));
+export default CheckBox;

package/dist/import/components/Multiselect/components/Indicator.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+type IndicatorProps = {
+    isHighlighted: boolean;
+};
+declare const Indicator: ({ isHighlighted }: IndicatorProps) => React.JSX.Element;
+export default Indicator;

package/dist/import/components/Multiselect/components/Indicator.js

@@ -0,0 +1,6 @@
+import figures from 'figures';
+import { Box, Text } from 'ink';
+import React from 'react';
+const Indicator = ({ isHighlighted = false }) => (React.createElement(Box, { marginRight: 1 },
+    React.createElement(Text, { color: isHighlighted ? 'green' : undefined }, isHighlighted ? figures.pointer : ' ')));
+export default Indicator;

package/dist/import/components/Multiselect/components/Item.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type ItemProps = {
+    isHighlighted: boolean;
+    label: string;
+};
+declare const Item: ({ isHighlighted, label }: ItemProps) => React.JSX.Element;
+export default Item;

package/dist/import/components/Multiselect/components/Item.js

@@ -0,0 +1,4 @@
+import { Text } from 'ink';
+import React from 'react';
+const Item = ({ isHighlighted = false, label }) => (React.createElement(Text, { color: isHighlighted ? 'green' : 'white', bold: isHighlighted }, label));
+export default Item;

package/dist/import/components/Multiselect/index.d.ts

@@ -0,0 +1 @@
+export { default, type Item, Indicator, CheckBox, ItemComponent } from './MultiSelect.js';

package/dist/import/components/Multiselect/index.js

@@ -0,0 +1 @@
+export { default, Indicator, CheckBox, ItemComponent } from './MultiSelect.js';

package/dist/import/components/steps/CloneRepo/CloneRepo.d.ts

@@ -0,0 +1,13 @@
+import { type FC } from 'react';
+interface Props {
+    projectName: string;
+    onCompletion: () => void;
+}
+/**
+ * Step for cloning the repository.
+ * @param projectName
+ * @param onCompletion
+ * @constructor
+ */
+declare const CloneRepo: FC<Props>;
+export default CloneRepo;

package/dist/import/components/steps/CloneRepo/CloneRepo.js

@@ -0,0 +1,13 @@
+import React from 'react';
+import Divider from '../../Divider.js';
+import Commands from './Commands.js';
+/**
+ * Step for cloning the repository.
+ * @param projectName
+ * @param onCompletion
+ * @constructor
+ */
+const CloneRepo = ({ projectName, onCompletion }) => (React.createElement(React.Fragment, null,
+    React.createElement(Divider, { title: 'Git tasks' }),
+    React.createElement(Commands, { projectName: projectName, onCompletion: onCompletion })));
+export default CloneRepo;

package/dist/import/components/steps/CloneRepo/Commands.d.ts

@@ -0,0 +1,12 @@
+import { type FC } from 'react';
+interface Props {
+    projectName: string;
+    onCompletion: () => void;
+}
+/**
+ * Executes all the commands to clone the dAppBooster repository.
+ * @param projectName
+ * @param onCompletion
+ */
+declare const Commands: FC<Props>;
+export default Commands;

package/dist/import/components/steps/CloneRepo/Commands.js

@@ -0,0 +1,29 @@
+import { join } from 'node:path';
+import * as process from 'node:process';
+import { Box, Text } from 'ink';
+import { Script, Spawn } from 'ink-spawn';
+import React from 'react';
+import { repoUrl } from '../../../constants/config.js';
+/**
+ * Executes all the commands to clone the dAppBooster repository.
+ * @param projectName
+ * @param onCompletion
+ */
+const Commands = ({ projectName, onCompletion }) => {
+    const projectFolder = join(process.cwd(), projectName);
+    return (React.createElement(Box, { flexDirection: 'column', gap: 0 },
+        React.createElement(Script, null,
+            React.createElement(Box, { columnGap: 1 },
+                React.createElement(Text, { color: 'whiteBright' }, "Cloning dAppBooster in"),
+                React.createElement(Text, { italic: true }, projectName)),
+            React.createElement(Spawn, { shell: true, silent: true, successText: 'Done!', failureText: `Failed to clone the project, check if a folder called "${projectName}" already exists and your read/write permissions...`, runningText: 'Working...', command: "git", args: ['clone', '--depth', '1', '--no-checkout', repoUrl, projectName] }),
+            React.createElement(Text, { color: 'whiteBright' }, "Fetching tags"),
+            React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: 'git', args: ['fetch', '--tags'], runningText: 'Working...', successText: 'Done!', failureText: 'Error...' }),
+            React.createElement(Text, { color: 'whiteBright' }, "Checking out latest tag"),
+            React.createElement(Spawn, { shell: true, cwd: projectFolder, command: "git", args: ['checkout $(git describe --tags `git rev-list --tags --max-count=1`)'], successText: "Done!", failureText: 'Error...' }),
+            React.createElement(Text, { color: 'whiteBright' }, "Removing .git folder"),
+            React.createElement(Spawn, { shell: true, cwd: projectFolder, command: "rm", args: ['-rf', '.git'], successText: "Done!", failureText: 'Error...' }),
+            React.createElement(Text, { color: 'whiteBright' }, "Initializing Git repository"),
+            React.createElement(Spawn, { shell: true, cwd: projectFolder, command: "git", args: ['init'], successText: "Done!", failureText: 'Error...', onCompletion: onCompletion }))));
+};
+export default Commands;

package/dist/import/components/steps/FileCleanup.d.ts

@@ -0,0 +1,18 @@
+import { type FC } from 'react';
+import type { InstallationType, MultiSelectItem } from '../../types/types.js';
+interface Props {
+    onCompletion: () => void;
+    projectName: string;
+    installationConfig: {
+        installationType: InstallationType | undefined;
+        selectedFeatures?: Array<MultiSelectItem>;
+    };
+}
+/**
+ * Performs file cleanup after the installation process
+ * @param onCompletion
+ * @param installation
+ * @param projectName
+ */
+declare const FileCleanup: FC<Props>;
+export default FileCleanup;

package/dist/import/components/steps/FileCleanup.js

@@ -0,0 +1,72 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Box, Text } from 'ink';
+import { Script, Spawn } from 'ink-spawn';
+import React, { useMemo } from 'react';
+import { featureSelected, getProjectFolder } from '../../utils/utils.js';
+import Divider from '../Divider.js';
+const packageJSONCleanup = (projectFolder, selectedFeatures) => {
+    const packageJSONPath = join(projectFolder, 'package.json');
+    const packageJSON = JSON.parse(readFileSync(packageJSONPath, 'utf8'));
+    if (!featureSelected('subgraph', selectedFeatures)) {
+        packageJSON.scripts['subgraph-codegen'] = undefined;
+    }
+    if (!featureSelected('typedoc', selectedFeatures)) {
+        packageJSON.scripts['typedoc:build'] = undefined;
+    }
+    if (!featureSelected('vocs', selectedFeatures)) {
+        packageJSON.scripts['docs:build'] = undefined;
+        packageJSON.scripts['docs:dev'] = undefined;
+        packageJSON.scripts['docs:preview'] = undefined;
+    }
+    if (!featureSelected('husky', selectedFeatures)) {
+        packageJSON.scripts.prepare = undefined;
+    }
+    writeFileSync(packageJSONPath, `${JSON.stringify(packageJSON, null, 2)}\n`);
+};
+/**
+ * Performs file cleanup after the installation process
+ * @param onCompletion
+ * @param installation
+ * @param projectName
+ */
+const FileCleanup = ({ onCompletion, installationConfig, projectName }) => {
+    const { installationType, selectedFeatures } = installationConfig;
+    const projectFolder = useMemo(() => getProjectFolder(projectName), [projectName]);
+    const currentHomeFolder = `${projectFolder}/src/components/pageComponents/home`;
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Divider, { title: 'File cleanup' }),
+        React.createElement(Box, { flexDirection: 'column', gap: 0 },
+            React.createElement(Script, null,
+                installationType === 'custom' && (React.createElement(Script, { onCompletion: () => packageJSONCleanup(projectFolder, selectedFeatures) },
+                    !featureSelected('demo', selectedFeatures) && (React.createElement(Script, null,
+                        React.createElement(Text, { color: 'whiteBright' }, "Component demos"),
+                        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['-rf', currentHomeFolder], runningText: 'Removing home files...', successText: 'Done!', failureText: 'Error...' }),
+                        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "mkdir", args: ['-p', currentHomeFolder], runningText: 'Creating home folder...', successText: 'Done!', failureText: 'Error...' }),
+                        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "cp", args: ['./.install-files/home/index.tsx', currentHomeFolder], runningText: 'Creating new home page file...', successText: 'Done!', failureText: 'Error...' }))),
+                    !featureSelected('subgraph', selectedFeatures) && (React.createElement(Script, null,
+                        React.createElement(Text, { color: 'whiteBright' }, "Subgraph"),
+                        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['-rf', './src/subgraphs'], runningText: 'Removing subgraphs folder...', successText: 'Done!', failureText: 'Error...' }),
+                        featureSelected('demo', selectedFeatures) && (React.createElement(Script, null,
+                            React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['-rf', `${currentHomeFolder}/Examples/demos/subgraphs`], runningText: 'Removing subgraphs demos folder...', successText: 'Done!', failureText: 'Error...' }),
+                            React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: [`${currentHomeFolder}/index.tsx`], runningText: 'Removing home page file...', successText: 'Done!', failureText: 'Error...' }),
+                            React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "cp", args: [
+                                    './.install-files/home/Examples/index.tsx',
+                                    `${currentHomeFolder}/index.tsx`,
+                                ], runningText: 'Creating new home page file...', successText: 'Done!', failureText: 'Error...' }))))),
+                    !featureSelected('typedoc', selectedFeatures) && (React.createElement(Script, null,
+                        React.createElement(Text, { color: 'whiteBright' }, "Typedoc"),
+                        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['./typedoc.json'], runningText: 'Removing config...', successText: 'Done!', failureText: 'Error...' }))),
+                    !featureSelected('vocs', selectedFeatures) && (React.createElement(Script, null,
+                        React.createElement(Text, { color: 'whiteBright' }, "Vocs"),
+                        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['./vocs.config.ts'], runningText: 'Removing config...', successText: 'Done!', failureText: 'Error...' }),
+                        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['-rf', './docs'], runningText: 'Removing docs folder...', successText: 'Done!', failureText: 'Error...' }))),
+                    !featureSelected('husky', selectedFeatures) && (React.createElement(Script, null,
+                        React.createElement(Text, { color: 'whiteBright' }, "Husky"),
+                        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['-rf', './.husky'], runningText: 'Removing Husky folder...', successText: 'Done!', failureText: 'Error...' }),
+                        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['./.lintstagedrc.mjs'], runningText: 'Removing lint-staged config...', successText: 'Done!', failureText: 'Error...' }),
+                        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['./commitlint.config.js'], runningText: 'Removing commitlint config...', successText: 'Done!', failureText: 'Error...' }))))),
+                React.createElement(Text, { color: 'whiteBright' }, "Install script"),
+                React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: "rm", args: ['-rf', './.install-files'], runningText: 'Removing folder...', successText: 'Done!', failureText: 'Error...', onCompletion: onCompletion })))));
+};
+export default FileCleanup;

package/dist/import/components/steps/Install/CustomInstallation.d.ts

@@ -0,0 +1,16 @@
+import { type FC } from 'react';
+import type { MultiSelectItem } from '../../../types/types.js';
+interface Props {
+    onCompletion: () => void;
+    projectFolder: string;
+    selectedFeatures?: Array<MultiSelectItem>;
+}
+/**
+ * Performs a custom installation based on the selected features: basically we tell `pnpm` what
+ * features to remove (everything's included in package.json by default to simplify things)
+ * @param onCompletion
+ * @param selectedFeatures
+ * @param projectFolder
+ */
+declare const CustomInstallation: FC<Props>;
+export default CustomInstallation;

package/dist/import/components/steps/Install/CustomInstallation.js

@@ -0,0 +1,31 @@
+import { Box, Text } from 'ink';
+import { Script, Spawn } from 'ink-spawn';
+import React from 'react';
+import { getPackages } from '../../../utils/utils.js';
+import InstallAllPackages from './InstallAllPackages.js';
+/**
+ * Performs a custom installation based on the selected features: basically we tell `pnpm` what
+ * features to remove (everything's included in package.json by default to simplify things)
+ * @param onCompletion
+ * @param selectedFeatures
+ * @param projectFolder
+ */
+const CustomInstallation = ({ onCompletion, selectedFeatures, projectFolder }) => {
+    // Collects the packages to remove based on the selected features and makes
+    // a string out of them so that we can pass it to `pnpm remove` command.
+    const packagesToRemove = [
+        ...getPackages('subgraph', selectedFeatures),
+        ...getPackages('typedoc', selectedFeatures),
+        ...getPackages('vocs', selectedFeatures),
+        ...getPackages('husky', selectedFeatures),
+    ]
+        .join(' ')
+        .trim();
+    return (React.createElement(Box, { flexDirection: 'column', gap: 0 }, !packagesToRemove ? (React.createElement(Script, null,
+        React.createElement(InstallAllPackages, { projectFolder: projectFolder, onCompletion: onCompletion }))) : (React.createElement(Script, null,
+        React.createElement(Text, { color: 'whiteBright' }, "Installing packages"),
+        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: 'pnpm', args: ['remove', packagesToRemove], runningText: 'Working...', successText: 'Done!', failureText: 'Error...' }),
+        React.createElement(Text, { color: 'whiteBright' }, "Executing post-install scripts"),
+        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: 'pnpm', args: ['run', 'postinstall'], runningText: 'Working...', successText: 'Done!', failureText: 'Error...', onCompletion: onCompletion })))));
+};
+export default CustomInstallation;

package/dist/import/components/steps/Install/FullInstallation.d.ts

@@ -0,0 +1,7 @@
+import { type FC } from 'react';
+interface Props {
+    projectFolder: string;
+    onCompletion?: () => void;
+}
+declare const FullInstallation: FC<Props>;
+export default FullInstallation;

package/dist/import/components/steps/Install/FullInstallation.js

@@ -0,0 +1,10 @@
+import { Box } from 'ink';
+import { Script } from 'ink-spawn';
+import React from 'react';
+import InstallAllPackages from './InstallAllPackages.js';
+const FullInstallation = ({ onCompletion, projectFolder }) => {
+    return (React.createElement(Box, { flexDirection: 'column', gap: 0 },
+        React.createElement(Script, null,
+            React.createElement(InstallAllPackages, { projectFolder: projectFolder, onCompletion: onCompletion }))));
+};
+export default FullInstallation;

package/dist/import/components/steps/Install/Install.d.ts

@@ -0,0 +1,12 @@
+import { type FC } from 'react';
+import type { InstallationType, MultiSelectItem } from '../../../types/types.js';
+interface Props {
+    installationConfig: {
+        installationType: InstallationType | undefined;
+        selectedFeatures?: Array<MultiSelectItem>;
+    };
+    projectName: string;
+    onCompletion: () => void;
+}
+declare const Install: FC<Props>;
+export default Install;

package/dist/import/components/steps/Install/Install.js

@@ -0,0 +1,29 @@
+import { Box, Text } from 'ink';
+import { Script, Spawn } from 'ink-spawn';
+import React, { useMemo } from 'react';
+import { getProjectFolder } from '../../../utils/utils.js';
+import Divider from '../../Divider.js';
+import CustomInstallation from './CustomInstallation.js';
+import FullInstallation from './FullInstallation.js';
+const Install = ({ projectName, onCompletion, installationConfig }) => {
+    const { installationType, selectedFeatures } = installationConfig;
+    const projectFolder = useMemo(() => getProjectFolder(projectName), [projectName]);
+    const title = installationType
+        ? installationType[0]?.toUpperCase() + installationType.slice(1)
+        : '';
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Divider, { title: `${title ?? 'Full'} installation` }),
+        React.createElement(Box, { flexDirection: 'column', gap: 0 },
+            React.createElement(Script, null,
+                React.createElement(Box, { columnGap: 1 },
+                    React.createElement(Text, { color: 'whiteBright' },
+                        "Creating",
+                        ' ',
+                        React.createElement(Text, { italic: true, color: 'white' }, ".env.local"),
+                        ' ',
+                        "file")),
+                React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: 'cp', args: ['.env.example', '.env.local'], runningText: 'Working...', successText: 'Done!', failureText: 'Error...' }),
+                installationType === 'full' && (React.createElement(FullInstallation, { onCompletion: onCompletion, projectFolder: projectFolder })),
+                installationType === 'custom' && (React.createElement(CustomInstallation, { selectedFeatures: selectedFeatures, onCompletion: onCompletion, projectFolder: projectFolder }))))));
+};
+export default Install;

package/dist/import/components/steps/Install/InstallAllPackages.d.ts

@@ -0,0 +1,7 @@
+import { type FC } from 'react';
+interface Props {
+    onCompletion?: () => void;
+    projectFolder: string;
+}
+declare const InstallAllPackages: FC<Props>;
+export default InstallAllPackages;

package/dist/import/components/steps/Install/InstallAllPackages.js

@@ -0,0 +1,9 @@
+import { Text } from 'ink';
+import { Spawn } from 'ink-spawn';
+import React from 'react';
+const InstallAllPackages = ({ projectFolder, onCompletion }) => {
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Text, { color: 'whiteBright' }, "Installing packages"),
+        React.createElement(Spawn, { shell: true, cwd: projectFolder, silent: true, command: 'pnpm', args: ['i'], runningText: 'Working...', successText: 'Done!', failureText: 'Error...', onCompletion: onCompletion })));
+};
+export default InstallAllPackages;

package/dist/import/components/steps/InstallationMode.d.ts

@@ -0,0 +1,8 @@
+import { type FC } from 'react';
+import type { InstallationSelectItem } from '../../types/types.js';
+interface Props {
+    onCompletion: () => void;
+    onSelect: (item: InstallationSelectItem) => void;
+}
+declare const InstallationMode: FC<Props>;
+export default InstallationMode;

package/dist/import/components/steps/InstallationMode.js

@@ -0,0 +1,28 @@
+import figures from 'figures';
+import { Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import React, { useState } from 'react';
+import Divider from '../Divider.js';
+const installationTypeItems = [
+    {
+        label: 'Full',
+        value: 'full',
+    },
+    {
+        label: 'Custom',
+        value: 'custom',
+    },
+];
+const InstallationMode = ({ onCompletion, onSelect }) => {
+    const [isFocused, setIsFocused] = useState(true);
+    const handleSelect = (item) => {
+        onSelect(item);
+        onCompletion();
+        setIsFocused(false);
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Divider, { title: 'Installation setup' }),
+        React.createElement(Text, { color: 'whiteBright' }, "Choose installation type"),
+        React.createElement(SelectInput, { indicatorComponent: ({ isSelected }) => (React.createElement(Text, { color: "green" }, isSelected ? `${figures.pointer} ` : '  ')), itemComponent: ({ label, isSelected }) => (React.createElement(Text, { color: isSelected ? 'green' : 'white', bold: isSelected }, label)), isFocused: isFocused, items: installationTypeItems, onSelect: handleSelect })));
+};
+export default InstallationMode;