@futurebrand/dev-tools 2.5.1 → 2.5.3

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

@@ -16,7 +16,7 @@ class Generator {
     get data() {
         return this.state.getData();
     }
-    async generateNextBlock(blockName, blockVariants, variables, styles, strapiComponent) {
+    async fetchNextBlock(blockName, blockVariants, variables, styles, strapiComponent) {
         const requestBody = {
             name: blockName.replace('block-', ''),
             variants: blockVariants,
@@ -24,54 +24,40 @@ class Generator {
             styles,
             strapiComponent,
         };
-        try {
-            const data = await this.state.fetchApi('/generate/nextjs/block', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(requestBody),
-            });
-            if (data.result?.block) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return data.result.block;
-            }
-            return null;
-        }
-        catch (error) {
-            console.error(error);
-            return null;
+        const data = await this.state.fetchApi('/generate/nextjs/block', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!data.result?.block) {
+            throw new Error('Next.js block generation failed');
         }
+        return data.result.block;
     }
-    async generateStrapiBlock(blockName, blockVariants) {
+    async fetchStrapiBlock(blockName, blockVariants) {
         const requestBody = {
             name: blockName.replace('block-', ''),
             variants: blockVariants,
         };
-        try {
-            const data = await this.state.fetchApi('/generate/strapi/block', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(requestBody),
-            });
-            if (data.result) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return data.result;
-            }
-            return null;
-        }
-        catch (error) {
-            console.error(error);
-            return null;
+        const data = await this.state.fetchApi('/generate/strapi/block', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!data.result) {
+            throw new Error('Strapi block generation failed');
         }
+        return data.result;
     }
     async loadProjectCSS(nextProject) {
         if (!nextProject) {
             return null;
         }
-        const cssFile = path.join(nextProject.path, 'styles', 'index.css');
+        const cssFile = path.join(nextProject.srcPath, 'styles', 'index.css');
         try {
             const css = await fs.readFile(cssFile, 'utf-8');
             if (!css) {
@@ -84,56 +70,52 @@ class Generator {
             return null;
         }
     }
-    async generateBlock(blockName, strapiProject, nextProject, styles, onGenerateCallback) {
+    async generateStrapiBlock(blockName, project, blockVariants) {
+        const isAlreadyGenerated = await this.state.file.verifyBlockAlreadyGenerated(blockName, project);
+        if (isAlreadyGenerated) {
+            const content = await this.state.file.loadGeneratedBlock(blockName, project);
+            return JSON.parse(content);
+        }
+        const response = await this.fetchStrapiBlock(blockName, blockVariants);
+        await this.state.file.saveGeneratedBlock(blockName, project, response);
+        return response;
+    }
+    async generateNextBlock(blockName, project, blockVariants) {
+        const strapiProject = this.data.projects.find((p) => p.type === 'strapi');
+        const strapiBlock = strapiProject
+            ? await this.generateStrapiBlock(blockName, strapiProject, blockVariants)
+            : undefined;
+        const styles = await this.loadProjectCSS(project);
+        const nextResponse = await this.fetchNextBlock(blockName, blockVariants, this.data.variables, styles, strapiBlock);
+        await this.state.file.saveGeneratedBlock(blockName, project, nextResponse);
+    }
+    async generateBlock(blockName, project) {
         try {
             const blockVariants = this.state.getBlockVariants(blockName);
-            const tempFolder = await (0, files_1.getTempFilePath)(exports.GENERATOR_FOLDER_NAME, blockName);
-            await (0, files_1.verifyAndCreateFolder)(tempFolder);
-            let strapiResponse = null;
-            if (strapiProject) {
-                strapiResponse = await this.generateStrapiBlock(blockName, blockVariants);
-                onGenerateCallback();
-                if (strapiResponse) {
-                    const cachePath = path.join(tempFolder, exports.GENERATOR_STRAPI_FILE_NAME);
-                    await fs.writeFile(cachePath, JSON.stringify(strapiResponse, null, 2));
-                }
+            await this.state.file.createBlockTempFolder(blockName);
+            if (project.type === 'strapi') {
+                return this.generateStrapiBlock(blockName, project, blockVariants);
             }
-            if (nextProject) {
-                const nextResponse = await this.generateNextBlock(blockName, blockVariants, this.data.variables, styles, strapiResponse);
-                onGenerateCallback();
-                if (nextResponse) {
-                    const cachePath = path.join(tempFolder, exports.GENERATOR_NEXTJS_FILE_NAME);
-                    await fs.writeFile(cachePath, nextResponse);
-                }
+            if (project.type === 'next.js') {
+                await this.generateNextBlock(blockName, project, blockVariants);
             }
-            this.state.setBlockGenerated(blockName);
         }
         catch (error) {
             console.error(error);
         }
     }
-    async generateBlocks(blockNames) {
+    async generateBlocks(blockNames, project) {
         if (!blockNames.length) {
-            console.error('No blocks selected');
-            return;
+            throw new Error('No blocks to generate');
+        }
+        if (project.type !== 'strapi' && project.type !== 'next.js') {
+            throw new Error('Project type not supported');
         }
         console.log('- Generating Blocks... Please wait');
-        const strapiProject = this.data.projects.find((project) => project.type === 'strapi');
-        const nextProject = this.data.projects.find((project) => project.type === 'next.js');
-        const styles = await this.loadProjectCSS(nextProject);
         const progressBar = new cliProgress.SingleBar({}, cliProgress.Presets.legacy);
-        let length = 0;
-        if (strapiProject) {
-            length += blockNames.length;
-        }
-        if (nextProject) {
-            length += blockNames.length;
-        }
-        progressBar.start(length, 0);
+        progressBar.start(blockNames.length, 0);
         for (const block of blockNames) {
-            await this.generateBlock(block, strapiProject, nextProject, styles, () => {
-                progressBar.increment();
-            });
+            await this.generateBlock(block, project);
         }
         progressBar.stop();
         await this.state.save();

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

@@ -0,0 +1,17 @@
+export interface IStrapiComponent {
+    collectionName: string;
+    info: {
+        name: string;
+        displayName: string;
+        description: string;
+    };
+    options: Record<string, unknown>;
+    attributes: Record<string, unknown>;
+}
+export interface IStrapiGenerateResponse {
+    block: IStrapiComponent;
+    assets: IStrapiComponent[];
+}
+export interface INextjsGenerateResponse {
+    block: string;
+}

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

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

package/dist/commands/ai/modules/project-adder/index.d.ts

@@ -1,10 +1,9 @@
+import type { IProject } from '../../../../types/project';
 import type AIState from '../state';
 declare class ProjectAdder {
     private state;
     constructor(state: AIState);
     private get data();
-    private createStrapiFiles;
-    private createNextjsFiles;
-    addBlock(blockName: string): Promise<void>;
+    addBlock(blockName: string, project: IProject): Promise<void>;
 }
 export default ProjectAdder;

package/dist/commands/ai/modules/project-adder/index.js

@@ -1,9 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const fs = require("node:fs/promises");
-const path = require("node:path");
-const files_1 = require("../../../../utils/files");
-const generator_1 = require("../generator");
 class ProjectAdder {
     state;
     constructor(state) {
@@ -12,66 +8,18 @@ class ProjectAdder {
     get data() {
         return this.state.getData();
     }
-    async createStrapiFiles(filePath, block) {
-        const strapiProject = this.data.projects.find((project) => project.type === 'strapi');
-        if (!strapiProject) {
-            throw new Error('Strapi project not found');
-            // return
-        }
-        const componentsFolder = path.join(strapiProject.path, 'src', 'components');
-        const blocksFolder = path.join(componentsFolder, 'blocks');
-        const blocksAssetsFolder = path.join(componentsFolder, 'blocks-assets');
-        const strapiResult = await (0, files_1.loadJSONFile)(filePath);
-        const blockData = strapiResult.block;
-        const assets = strapiResult.assets;
-        await (0, files_1.verifyAndCreateFolder)(blocksFolder);
-        await (0, files_1.verifyAndCreateFolder)(blocksAssetsFolder);
-        for (const asset of assets) {
-            const name = asset.info?.name;
-            if (!name) {
-                console.warn('Asset name is missing, skipping asset creation');
-                continue;
-            }
-            await fs.writeFile(path.join(blocksAssetsFolder, `${name}.json`), JSON.stringify(asset, null, 2));
-        }
-        const blockName = block.name.replace('block-', '');
-        await fs.writeFile(path.join(blocksFolder, `${blockName}.json`), JSON.stringify(blockData, null, 2));
-    }
-    async createNextjsFiles(filePath, block) {
-        const project = this.data.projects.find((project) => project.type === 'next.js');
-        if (!project) {
-            throw new Error('Nextjs project not found');
-            // return
-        }
-        const blockFolder = path.join(project.path, 'layouts', 'blocks', block.name);
-        await (0, files_1.verifyAndCreateFolder)(blockFolder);
-        const nextjsResult = await (0, files_1.loadFile)(filePath);
-        await fs.writeFile(path.join(blockFolder, `${block.name}.tsx`), nextjsResult);
-        const indexContent = `export { default } from './${block.name}'`;
-        await fs.writeFile(path.join(blockFolder, 'index.ts'), indexContent);
-    }
-    async addBlock(blockName) {
+    async addBlock(blockName, project) {
         const block = this.data.blocks.find((block) => block.name === blockName);
-        if (!block || !block.generated) {
+        if (!block) {
             console.error(`Block ${blockName} not found`);
             return;
         }
-        const strapiTempFilePath = await (0, files_1.getTempFilePath)(generator_1.GENERATOR_FOLDER_NAME, blockName, generator_1.GENERATOR_STRAPI_FILE_NAME);
-        const nextTempFilePath = await (0, files_1.getTempFilePath)(generator_1.GENERATOR_FOLDER_NAME, blockName, generator_1.GENERATOR_NEXTJS_FILE_NAME);
-        if (await (0, files_1.verifyPath)(strapiTempFilePath)) {
-            await this.createStrapiFiles(strapiTempFilePath, block);
-        }
-        else {
-            console.warn(`Strapi file for block ${blockName} not found in ${strapiTempFilePath}`);
-        }
-        if (await (0, files_1.verifyPath)(nextTempFilePath)) {
-            await this.createNextjsFiles(nextTempFilePath, block);
+        if (project.type === 'strapi') {
+            await this.state.file.addStrapiBlockToProject(block.name, project);
         }
-        else {
-            console.warn(`Next.js file for block ${blockName} not found in ${nextTempFilePath}`);
+        else if (project.type === 'next.js') {
+            await this.state.file.addNextBlockToProject(block.name, project);
         }
-        this.state.setBlockHidden(blockName, true);
-        await this.state.save();
         console.log(`Block ${blockName} added successfully`);
     }
 }

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

@@ -1,7 +1,10 @@
+import FileManager from '../file-manager';
 import type { IAIFileState, IAvailableFilters } from './types';
 declare class AIState {
     private filePath;
     private data;
+    private server;
+    file: FileManager;
     constructor();
     private createOptions;
     create(): Promise<void>;

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

@@ -1,13 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const ai_server_module_1 = require("../../../../modules/ai-server-module");
 const project_1 = require("../../../../utils/project");
 const inquirer_1 = require("inquirer");
 const files_1 = require("../../../../utils/files");
+const file_manager_1 = require("../file-manager");
 const FILE_NAME = 'ai-state.json';
 class AIState {
     filePath = '';
     data = null;
-    constructor() { }
+    server;
+    file;
+    constructor() {
+        this.server = new ai_server_module_1.default();
+        this.file = new file_manager_1.default();
+    }
     async createOptions() {
         const query = await inquirer_1.default.prompt([
             {
@@ -40,34 +47,23 @@ class AIState {
     }
     async create() {
         this.data = await this.createOptions();
+        this.server.setApiConfigs(this.data.configs);
     }
     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;
+        return this.server.fetchApi(path, init);
     }
     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);
+            this.server.setApiConfigs(this.data.configs);
         }
     }
     async save() {
-        await (0, files_1.writeJSONFile)(this.filePath, this.data);
+        if (this.data) {
+            await (0, files_1.writeJSONFile)(this.filePath, this.data);
+            await this.server.save();
+        }
     }
     get isReady() {
         return this.data !== null;

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

@@ -1,8 +1,7 @@
+import type { IServerConfigs } from '../../../../modules/ai-server-module/types';
 import type { IProject } from '../../../../types/project';
 import type { IFigmaNode } from '../figma/types';
-export interface IStateConfigs {
-    api: string;
-    token: string;
+export interface IStateConfigs extends IServerConfigs {
     figma: string;
 }
 export interface IBlockData {

package/dist/modules/ai-server-module/index.d.ts

@@ -0,0 +1,15 @@
+import type { IServerConfigs } from './types';
+declare class AIServerModule implements IServerConfigs {
+    private filePath;
+    api: string;
+    token: string;
+    constructor();
+    private createConfigs;
+    create(): Promise<void>;
+    fetchApi<T = any>(path: string, init?: RequestInit): Promise<T>;
+    init(): Promise<void>;
+    setApiConfigs(configs: IServerConfigs): void;
+    save(): Promise<void>;
+    get isReady(): boolean;
+}
+export default AIServerModule;

package/dist/modules/ai-server-module/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const inquirer_1 = require("inquirer");
+const files_1 = require("../../utils/files");
+const FILE_NAME = 'ai-server.json';
+class AIServerModule {
+    filePath = '';
+    api = '';
+    token = '';
+    constructor() { }
+    async createConfigs() {
+        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?',
+            },
+        ]);
+        return {
+            api: query.apiUrl,
+            token: query.apiToken,
+        };
+    }
+    async create() {
+        const configs = await this.createConfigs();
+        this.api = configs.api;
+        this.token = configs.token;
+    }
+    async fetchApi(path, init) {
+        if (!this.isReady) {
+            await this.init();
+        }
+        let apiUrl = this.api;
+        if (apiUrl.endsWith('/')) {
+            apiUrl = apiUrl.slice(0, -1);
+        }
+        const response = await fetch(`${apiUrl}${path}`, {
+            ...init,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.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)) {
+            const configs = await (0, files_1.loadJSONFile)(this.filePath);
+            this.setApiConfigs(configs);
+        }
+        else {
+            const configs = await this.createConfigs();
+            this.setApiConfigs(configs);
+            await this.save();
+        }
+    }
+    setApiConfigs(configs) {
+        this.api = configs.api;
+        this.token = configs.token;
+    }
+    async save() {
+        if (!this.isReady) {
+            throw new Error('AIServerModule is not ready. Please initialize it first.');
+        }
+        const filePath = this.filePath || (await (0, files_1.getTempFilePath)(FILE_NAME));
+        await (0, files_1.writeJSONFile)(filePath, {
+            api: this.api,
+            token: this.token,
+        });
+    }
+    get isReady() {
+        return this.api !== '' && this.token !== '';
+    }
+}
+exports.default = AIServerModule;

package/dist/modules/ai-server-module/types.d.ts

@@ -0,0 +1,4 @@
+export interface IServerConfigs {
+    api: string;
+    token: string;
+}

package/dist/modules/ai-server-module/types.js

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

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

@@ -1,16 +1,11 @@
 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>;
+    execute(): Promise<void>;
     reset(): void;
 }
 export default ParallelModule;

package/dist/modules/parallel/index.js

@@ -1,50 +1,32 @@
 "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;
+        this.running = new Set();
     }
     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();
+    async execute() {
+        for (const promise of this.promises) {
+            const task = promise().then(() => {
+                this.running.delete(task);
+            });
+            this.running.add(task);
+            if (this.running.size >= this.parallelCalls) {
+                await Promise.race(this.running);
             }
-            void this.next(callback);
         }
+        await Promise.all(this.running);
     }
     reset() {
         this.promises = [];
-        this.running = 0;
-        this.index = 0;
+        this.running = new Set();
     }
 }
 exports.default = ParallelModule;

package/dist/types/project.d.ts

@@ -2,6 +2,7 @@ export type ProjectType = 'next.js' | 'react' | 'strapi' | 'node';
 interface IDefaultProject {
     name: string;
     path: string;
+    srcPath: string;
     relativePath: string;
     type: ProjectType;
 }

package/dist/utils/files.d.ts

@@ -8,3 +8,5 @@ export declare function writeJSONFile(filePath: string, data: unknown): Promise<
 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>;
+export declare function getDirectoriesInPath(rootPath: string): Promise<string[]>;
+export declare function getFilesInPath(rootPath: string): Promise<string[]>;

package/dist/utils/files.js

@@ -10,6 +10,8 @@ exports.writeJSONFile = writeJSONFile;
 exports.writeRootFile = writeRootFile;
 exports.writeFile = writeFile;
 exports.loadFile = loadFile;
+exports.getDirectoriesInPath = getDirectoriesInPath;
+exports.getFilesInPath = getFilesInPath;
 const fs = require("node:fs/promises");
 const path = require("path");
 async function verifyPath(filePath) {
@@ -82,3 +84,43 @@ async function loadFile(filePath) {
         throw error;
     }
 }
+async function getDirectoriesInPath(rootPath) {
+    const directories = [];
+    try {
+        const allContent = await fs.readdir(rootPath);
+        for (const content of allContent) {
+            const contentPath = path.join(rootPath, content);
+            const stats = await fs.stat(contentPath);
+            if (stats.isDirectory()) {
+                directories.push(content);
+            }
+        }
+        return directories;
+    }
+    catch (error) {
+        console.error(`Error reading directory ${rootPath}:`, error);
+        return directories;
+    }
+}
+async function getFilesInPath(rootPath) {
+    const files = [];
+    try {
+        const allContent = await fs.readdir(rootPath);
+        for (const content of allContent) {
+            const contentPath = path.join(rootPath, content);
+            const stats = await fs.stat(contentPath);
+            if (stats.isFile()) {
+                files.push(contentPath);
+            }
+            else if (stats.isDirectory()) {
+                const subFiles = await getFilesInPath(contentPath);
+                files.push(...subFiles);
+            }
+        }
+        return files;
+    }
+    catch (error) {
+        console.error(`Error reading directory ${rootPath}:`, error);
+        return files;
+    }
+}