@futurebrand/dev-tools 2.1.2 → 2.4.0

package/dist/commands/ai/modules/state/index.d.ts

@@ -0,0 +1,23 @@
+import type { IAIFileState, IAvailableFilters } from './types';
+declare class AIState {
+    private filePath;
+    private data;
+    constructor();
+    private createOptions;
+    create(): Promise<void>;
+    fetchApi<T = any>(path: string, init?: RequestInit): Promise<T>;
+    init(): Promise<void>;
+    save(): Promise<void>;
+    get isReady(): boolean;
+    getData(): IAIFileState;
+    getAvailableBlocks({ generated, hidden }?: IAvailableFilters): import("./types").IBlockData[];
+    getAvailableBlocksNames(filters?: IAvailableFilters): string[];
+    setBlocks(blocks: IAIFileState['blocks']): void;
+    setVariables(variables: IAIFileState['variables']): void;
+    setColors(colors: IAIFileState['colors']): void;
+    setBlockGenerated(blockName: string, generated?: boolean): void;
+    getBlockVariants(blockName: string): any[];
+    setBlockHidden(blockName: string, hidden?: boolean): void;
+    static init(): Promise<AIState>;
+}
+export default AIState;

package/dist/commands/ai/modules/state/index.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const project_1 = require("../../../../utils/project");
+const inquirer_1 = require("inquirer");
+const files_1 = require("../../../../utils/files");
+const FILE_NAME = 'ai-state.json';
+class AIState {
+    filePath = '';
+    data = null;
+    constructor() { }
+    async createOptions() {
+        const query = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'apiUrl',
+                message: 'What is the AI API url?',
+            },
+            {
+                type: 'input',
+                name: 'apiToken',
+                message: 'What is the AI API token?',
+            },
+            {
+                type: 'input',
+                name: 'page',
+                message: 'What is the Figma Page ID?',
+            },
+        ]);
+        const projects = await (0, project_1.getProjects)();
+        return {
+            configs: {
+                api: query.apiUrl,
+                token: query.apiToken,
+                figma: query.page,
+            },
+            projects,
+            blocks: [],
+            variables: {},
+        };
+    }
+    async create() {
+        this.data = await this.createOptions();
+    }
+    async fetchApi(path, init) {
+        let apiUrl = this.getData().configs.api;
+        if (apiUrl.endsWith('/')) {
+            apiUrl = apiUrl.slice(0, -1);
+        }
+        const response = await fetch(`${apiUrl}${path}`, {
+            ...init,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.getData().configs.token}`,
+                ...init?.headers,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${path}`);
+        }
+        const data = await response.json();
+        return data;
+    }
+    async init() {
+        this.filePath = await (0, files_1.getTempFilePath)(FILE_NAME);
+        if (await (0, files_1.verifyPath)(this.filePath)) {
+            this.data = await (0, files_1.loadJSONFile)(this.filePath);
+        }
+    }
+    async save() {
+        await (0, files_1.writeJSONFile)(this.filePath, this.data);
+    }
+    get isReady() {
+        return this.data !== null;
+    }
+    getData() {
+        if (!this.data) {
+            throw new Error('AI State not initialized');
+        }
+        return this.data;
+    }
+    getAvailableBlocks({ generated, hidden } = {}) {
+        let blocks = this.getData().blocks;
+        if (hidden != null || generated != null) {
+            blocks = blocks.filter((block) => {
+                if (hidden != null && block.hidden !== hidden) {
+                    return false;
+                }
+                if (generated != null && block.generated !== generated) {
+                    return false;
+                }
+                return true;
+            });
+        }
+        return blocks;
+    }
+    getAvailableBlocksNames(filters = {}) {
+        const blocks = this.getAvailableBlocks(filters);
+        return blocks.map((block) => block.name);
+    }
+    setBlocks(blocks) {
+        this.data.blocks = blocks;
+    }
+    setVariables(variables) {
+        this.data.variables = variables;
+    }
+    setColors(colors) {
+        this.data.colors = colors;
+    }
+    setBlockGenerated(blockName, generated = true) {
+        const blocks = this.getData().blocks;
+        const block = blocks.find((block) => block.name === blockName);
+        if (block) {
+            block.generated = generated;
+        }
+    }
+    getBlockVariants(blockName) {
+        const blocks = this.getData().blocks.find((block) => block.name === blockName);
+        return blocks?.variants || [];
+    }
+    setBlockHidden(blockName, hidden = true) {
+        const blocks = this.getData().blocks;
+        const block = blocks.find((block) => block.name === blockName);
+        if (block) {
+            block.hidden = hidden;
+        }
+    }
+    static async init() {
+        const state = new AIState();
+        await state.init();
+        return state;
+    }
+}
+exports.default = AIState;

package/dist/commands/ai/modules/state/types.d.ts

@@ -0,0 +1,29 @@
+import type { IProject } from '../../../../types/project';
+import type { IFigmaNode } from '../figma/types';
+export interface IStateConfigs {
+    api: string;
+    token: string;
+    figma: string;
+}
+export interface IBlockData {
+    name: string;
+    hidden: boolean;
+    generated: boolean;
+    variants: IFigmaNode[];
+}
+export interface IProjectColor {
+    name: string;
+    value: string;
+    description: string;
+}
+export interface IAvailableFilters {
+    hidden?: boolean;
+    generated?: boolean;
+}
+export interface IAIFileState {
+    configs: IStateConfigs;
+    blocks: IBlockData[];
+    projects: IProject[];
+    variables: Record<string, any>;
+    colors?: IProjectColor[];
+}

package/dist/commands/ai/modules/state/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commands/ai/remove.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const removeCommand: Command;
+export default removeCommand;

package/dist/commands/ai/remove.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const inquirer_1 = require("inquirer");
+const state_1 = require("./modules/state");
+const removeCommand = new commander_1.Command('remove')
+    .alias('rm')
+    .alias('hide')
+    .description('Remove Blocks From block list')
+    .action(async () => {
+    const state = await state_1.default.init();
+    if (!state.isReady) {
+        console.error('AI State not initialized');
+        console.error('Run "fub ai --init" first');
+        return;
+    }
+    const choices = state.getAvailableBlocksNames({
+        hidden: false,
+    });
+    if (!choices.length) {
+        console.error('No blocks available to remove');
+        return;
+    }
+    const blockQuery = await inquirer_1.default.prompt([
+        {
+            type: 'checkbox',
+            name: 'blocks',
+            message: 'Select the blocks to delete',
+            choices,
+        },
+    ]);
+    const blocksToGenerate = blockQuery.blocks;
+    if (!blocksToGenerate.length) {
+        console.error('No blocks selected');
+        return;
+    }
+    for (const block of blocksToGenerate) {
+        state.setBlockHidden(block, true);
+    }
+    await state.save();
+});
+exports.default = removeCommand;

package/dist/commands/index.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from 'commander';
+interface CLIOptions {
+    version: string;
+    description: string;
+}
+export declare function addCommands(program: Command, cli: CLIOptions): void;
+export {};

package/dist/commands/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommands = addCommands;
+const ai_1 = require("./ai");
+const project_setup_1 = require("./project-setup");
+function addCommands(program, cli) {
+    program
+        .version(cli.version)
+        .description(cli.description)
+        .option('-n, --name <type>', 'Add your name')
+        .action((options) => {
+        if (options.name) {
+            console.warn(`Hello ${options.name}!`);
+        }
+        else {
+            console.warn('Hello Futurebrand!');
+        }
+    });
+    program.addCommand(project_setup_1.default);
+    program.addCommand(ai_1.default);
+}

package/dist/{bin/commands → commands}/project-setup/configs.d.ts

@@ -1,4 +1,4 @@
-import type { ProjectType } from '../../types';
+import type { ProjectType } from '../../types/project';
 export declare const UNUSED_FILES: string[];
 export declare const ESLINT_CONFIG_FILE = "eslint.config.mjs";
 export declare const PRETTIER_CONFIG_FILE = "prettier.config.mjs";

package/dist/{bin/commands → commands}/project-setup/configs.js

@@ -15,6 +15,7 @@ exports.PRETTIER_PLUGIN_NAME = 'PrettierConfig';
 exports.ESLINT_PLUGIN_NAMES = {
     'next.js': 'EslintNextjsConfigs',
     react: 'EslintReactjsConfigs',
+    strapi: 'EslintNodeConfigs',
     node: 'EslintNodeConfigs',
 };
 exports.DEV_DEPENDENCIES = [

package/dist/commands/project-setup/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/* eslint-disable no-console */
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const project_1 = require("../../utils/project");
+const files_1 = require("./utils/files");
+const lint_1 = require("./utils/lint");
+const packages_1 = require("./utils/packages");
+const projectSetup = new commander_1.Command('setup')
+    .description('Setup project with default configurations')
+    .action(async () => {
+    const projects = await (0, project_1.getProjects)();
+    for (const project of projects) {
+        console.log(`### Setting up ${project.name}...`);
+        console.log(`- Project path: ${project.relativePath}`);
+        console.log(`- Project type: ${String(project.type)}`);
+        await (0, files_1.deleteProjectUnusedFiles)(project);
+        await (0, lint_1.handleProjectLinters)(project);
+        await (0, packages_1.handleProjectDependencies)(project);
+    }
+});
+exports.default = projectSetup;

package/dist/commands/project-setup/utils/files.d.ts

@@ -0,0 +1,2 @@
+import type { IProject } from '../../../types/project';
+export declare function deleteProjectUnusedFiles(project: IProject): Promise<void>;

package/dist/commands/project-setup/utils/files.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteProjectUnusedFiles = deleteProjectUnusedFiles;
+const fs = require("node:fs/promises");
+const files_1 = require("../../../utils/files");
+const path = require("path");
+const configs_1 = require("../configs");
+async function deleteProjectUnusedFiles(project) {
+    for (const file of configs_1.UNUSED_FILES) {
+        const filePath = path.join(project.path, file);
+        try {
+            if (await (0, files_1.verifyPath)(filePath)) {
+                await fs.unlink(filePath);
+            }
+        }
+        catch (error) {
+            console.error(`Failed to delete ${filePath}`);
+            throw error;
+        }
+    }
+}

package/dist/commands/project-setup/utils/lint.d.ts

@@ -0,0 +1,3 @@
+import type { IProject } from '../../../types/project';
+export declare function getPluginConfig(pluginImportName: string): string;
+export declare function handleProjectLinters(project: IProject): Promise<void>;

package/dist/commands/project-setup/utils/lint.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPluginConfig = getPluginConfig;
+exports.handleProjectLinters = handleProjectLinters;
+const path = require("path");
+const files_1 = require("../../../utils/files");
+const configs_1 = require("../configs");
+function getPluginConfig(pluginImportName) {
+    return `import { ${pluginImportName} } from '@futurebrand/dev-tools/plugins'
+
+export default ${pluginImportName}`;
+}
+async function handleProjectLinters(project) {
+    const projectType = project.type;
+    const eslintConfigName = configs_1.ESLINT_PLUGIN_NAMES[projectType];
+    const eslintConfig = getPluginConfig(eslintConfigName);
+    const prettierConfig = getPluginConfig(configs_1.PRETTIER_PLUGIN_NAME);
+    const eslintConfigPath = path.join(project.path, configs_1.ESLINT_CONFIG_FILE);
+    const prettierConfigPath = path.join(project.path, configs_1.PRETTIER_CONFIG_FILE);
+    await (0, files_1.writeFile)(eslintConfigPath, eslintConfig);
+    await (0, files_1.writeFile)(prettierConfigPath, prettierConfig);
+}

package/dist/commands/project-setup/utils/packages.d.ts

@@ -0,0 +1,5 @@
+import type { IProject } from '../../../types/project';
+export declare function removeEslintDependencies(dependencies: Record<string, string>): void;
+export declare function removeUnusedPackages(project: IProject): Promise<void>;
+export declare function installDependencies(project: IProject): Promise<void>;
+export declare function handleProjectDependencies(project: IProject): Promise<void>;

package/dist/{bin/commands/project-setup/modules → commands/project-setup/utils}/packages.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeEslintDependencies = removeEslintDependencies;
 exports.removeUnusedPackages = removeUnusedPackages;
 exports.installDependencies = installDependencies;
-const files_1 = require("../../../modules/files");
-const package_manager_1 = require("../../../modules/package-manager");
+exports.handleProjectDependencies = handleProjectDependencies;
+const package_manager_1 = require("../../../utils/package-manager");
 const child_process_1 = require("child_process");
 const configs_1 = require("../configs");
 function removeEslintDependencies(dependencies) {
@@ -16,8 +16,11 @@ function removeEslintDependencies(dependencies) {
         }
     }
 }
-async function removeUnusedPackages() {
-    const PackageJson = await (0, files_1.loadPackageJson)();
+async function removeUnusedPackages(project) {
+    const PackageJson = await (0, package_manager_1.loadPackageJson)(project.path);
+    if (!PackageJson) {
+        return;
+    }
     removeEslintDependencies(PackageJson.devDependencies);
     removeEslintDependencies(PackageJson.dependencies);
     for (const dependency of configs_1.DEV_DEPENDENCIES) {
@@ -30,17 +33,23 @@ async function removeUnusedPackages() {
             PackageJson.devDependencies[dependency] = 'latest';
         }
     }
-    await (0, files_1.writePackageJson)(PackageJson);
+    await (0, package_manager_1.writePackageJson)(project.path, PackageJson);
 }
-async function installDependencies() {
-    const packageManager = await (0, package_manager_1.getPackageManager)();
-    const command = `${packageManager} install`;
+async function installDependencies(project) {
+    const packageManager = await (0, package_manager_1.getPackageManager)(project.path);
+    const command = `cd ${project.relativePath} && ${packageManager} install`;
     return new Promise((resolve, reject) => {
         (0, child_process_1.exec)(command, (error) => {
             if (error) {
+                console.error(`Failed to install dependencies for ${project.name}`);
+                console.error(`Please run "${packageManager} install" manually`);
                 reject(error);
             }
             resolve();
         });
     });
 }
+async function handleProjectDependencies(project) {
+    await removeUnusedPackages(project);
+    await installDependencies(project);
+}

package/dist/modules/parallel/index.d.ts

@@ -0,0 +1,16 @@
+type ParallelCallback = () => Promise<void>;
+type CycleCallback = (index: number, total: number) => void;
+declare class ParallelModule {
+    private readonly parallelCalls;
+    private promises;
+    private running;
+    private index;
+    constructor(parallelCalls: number);
+    add(callback: ParallelCallback): void;
+    private next;
+    private wait;
+    get total(): number;
+    execute(callback: CycleCallback): Promise<void>;
+    reset(): void;
+}
+export default ParallelModule;

package/dist/modules/parallel/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sleep_1 = require("../../utils/sleep");
+class ParallelModule {
+    parallelCalls;
+    promises;
+    running;
+    index;
+    constructor(parallelCalls) {
+        this.parallelCalls = parallelCalls;
+        this.promises = [];
+        this.running = 0;
+        this.index = 0;
+    }
+    add(callback) {
+        this.promises.push(callback);
+    }
+    async next(callback) {
+        const promise = this.promises.shift();
+        if (promise) {
+            this.running++;
+            await promise();
+            this.running--;
+        }
+        this.index++;
+        callback(this.index, this.total);
+    }
+    async wait() {
+        while (this.running >= this.parallelCalls) {
+            await (0, sleep_1.sleep)(0);
+        }
+    }
+    get total() {
+        return this.promises.length;
+    }
+    async execute(callback) {
+        while (this.promises.length > 0) {
+            if (this.running >= this.parallelCalls) {
+                await this.wait();
+            }
+            void this.next(callback);
+        }
+    }
+    reset() {
+        this.promises = [];
+        this.running = 0;
+        this.index = 0;
+    }
+}
+exports.default = ParallelModule;

package/dist/plugins/eslint/configs/configs.d.mts

@@ -1,5 +1,5 @@
 import { type ConfigArray } from 'typescript-eslint';
-export declare const MAX_COMPLEXITY = 15;
+export declare const MAX_COMPLEXITY = 20;
 export declare const MAX_LINES = 450;
 interface IConfigParams {
     node?: boolean;

package/dist/plugins/eslint/configs/configs.mjs

@@ -2,7 +2,7 @@ import pluginJs from '@eslint/js';
 import prettierRecommended from 'eslint-plugin-prettier/recommended';
 import globals from 'globals';
 import tseslint from 'typescript-eslint';
-export const MAX_COMPLEXITY = 15;
+export const MAX_COMPLEXITY = 20;
 export const MAX_LINES = 450;
 export function getBaseConfig({ node = false, browser = false, typescript = true, prettier = true, }) {
     const configs = [];

package/dist/plugins/eslint/node.mjs

@@ -23,6 +23,6 @@ export const EslintNodeConfigs = tseslint.config([
         },
     },
     {
-        ignores: ['strapi/**/*', 'types/generated/**/*'],
+        ignores: ['strapi/**/*', '.strapi/**/*', 'types/generated/**/*'],
     },
 ]);

package/dist/plugins/prettier/prettier.d.mts

@@ -24,13 +24,14 @@ export declare const NextjsPrettierConfigs: {
     filepath?: string | undefined;
     requirePragma?: boolean | undefined;
     insertPragma?: boolean | undefined;
+    checkIgnorePragma?: boolean | undefined;
     proseWrap?: "always" | "never" | "preserve" | undefined;
     arrowParens?: "always" | "avoid" | undefined;
-    htmlWhitespaceSensitivity?: "ignore" | "css" | "strict" | undefined;
+    htmlWhitespaceSensitivity?: "css" | "ignore" | "strict" | undefined;
     endOfLine?: "auto" | "lf" | "crlf" | "cr" | undefined;
     quoteProps?: "preserve" | "as-needed" | "consistent" | undefined;
     vueIndentScriptAndStyle?: boolean | undefined;
-    embeddedLanguageFormatting?: "off" | "auto" | undefined;
+    embeddedLanguageFormatting?: "auto" | "off" | undefined;
     singleAttributePerLine?: boolean | undefined;
     experimentalOperatorPosition?: "start" | "end" | undefined;
     experimentalTernaries?: boolean | undefined;
@@ -61,14 +62,15 @@ export declare const NodePrettierConfigs: {
     filepath?: string | undefined;
     requirePragma?: boolean | undefined;
     insertPragma?: boolean | undefined;
+    checkIgnorePragma?: boolean | undefined;
     proseWrap?: "always" | "never" | "preserve" | undefined;
     arrowParens?: "always" | "avoid" | undefined;
-    plugins?: (string | import("prettier").Plugin<any>)[] | undefined;
-    htmlWhitespaceSensitivity?: "ignore" | "css" | "strict" | undefined;
+    plugins?: (string | URL | import("prettier").Plugin<any>)[] | undefined;
+    htmlWhitespaceSensitivity?: "css" | "ignore" | "strict" | undefined;
     endOfLine?: "auto" | "lf" | "crlf" | "cr" | undefined;
     quoteProps?: "preserve" | "as-needed" | "consistent" | undefined;
     vueIndentScriptAndStyle?: boolean | undefined;
-    embeddedLanguageFormatting?: "off" | "auto" | undefined;
+    embeddedLanguageFormatting?: "auto" | "off" | undefined;
     singleAttributePerLine?: boolean | undefined;
     experimentalOperatorPosition?: "start" | "end" | undefined;
     experimentalTernaries?: boolean | undefined;

package/dist/types/project.d.ts

@@ -0,0 +1,20 @@
+export type ProjectType = 'next.js' | 'react' | 'strapi' | 'node';
+interface IDefaultProject {
+    name: string;
+    path: string;
+    relativePath: string;
+    type: ProjectType;
+}
+interface NextProject extends IDefaultProject {
+    type: 'next.js';
+    appDir: boolean;
+}
+export type IProject = NextProject | IDefaultProject;
+export interface PackageJson {
+    name: string;
+    version: string;
+    scripts: Record<string, string>;
+    devDependencies: Record<string, string>;
+    dependencies: Record<string, string>;
+}
+export {};

package/dist/types/project.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/files.d.ts

@@ -0,0 +1,10 @@
+export declare function verifyPath(filePath: string): Promise<boolean>;
+export declare function verifyAndCreateFolder(folderPath: string): Promise<void>;
+export declare function getRootPath(...paths: string[]): string;
+export declare function getTempFolder(): Promise<string>;
+export declare function getTempFilePath(...fileName: string[]): Promise<string>;
+export declare function loadJSONFile<T = any>(filePath: string): Promise<T>;
+export declare function writeJSONFile(filePath: string, data: unknown): Promise<void>;
+export declare function writeRootFile(fileName: string, content: string): Promise<void>;
+export declare function writeFile(filePath: string, content: string): Promise<void>;
+export declare function loadFile(filePath: string): Promise<string>;