fiboui 1.0.2 → 2.0.0

package/dist/cli/bin.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { Command } from 'commander';
+import { generateCommand } from './commands/generate';
+import { initCommand } from './commands/init';
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+const version = pkg.version;
+const program = new Command();
+program
+    .name('fibo')
+    .description('FiboUI CLI - Supercharge your development')
+    .version(version);
+// ... (version import)
+program.addCommand(initCommand);
+program.addCommand(generateCommand);
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/dist/cli/commands/generate/component.js

@@ -0,0 +1,67 @@
+import { Command } from 'commander';
+import prompts from 'prompts';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import ora from 'ora';
+export const componentCommand = new Command('component')
+    .alias('c')
+    .description('Generate a new FiboUI functional component')
+    .argument('[name]', 'Name of the component')
+    .action(async (name) => {
+    let componentName = name;
+    if (!componentName) {
+        const response = await prompts({
+            type: 'text',
+            name: 'value',
+            message: 'What is the name of your Component?',
+            validate: value => value.length < 3 ? 'Component name must be at least 3 characters' : true
+        });
+        componentName = response.value;
+    }
+    if (!componentName)
+        process.exit(1);
+    const spinner = ora(`Scaffolding component ${chalk.bold(componentName)}...`).start();
+    // Try to guess location: src/components or current dir
+    const srcComponents = path.resolve(process.cwd(), 'src/components');
+    const targetDir = (await fs.pathExists(srcComponents)) ? srcComponents : process.cwd();
+    // Create folder for component? Or just file? Let's do file for simplicity or folder if preferred.
+    // Standard: src/components/MyComponent/index.tsx
+    const componentDir = path.join(targetDir, componentName);
+    const targetFile = path.join(componentDir, 'index.tsx');
+    try {
+        if (await fs.pathExists(componentDir)) {
+            spinner.fail(`Component ${componentName} already exists at ${componentDir}`);
+            return;
+        }
+        await fs.ensureDir(componentDir);
+        const content = `import React from 'react';
+import { Component, Text, Row, FiboBuilder } from 'fiboui';
+
+export interface ${componentName}Props {
+  title?: string;
+}
+
+export const ${componentName} = Component<${componentName}Props>()(
+  ({ title = '${componentName}' }) => {
+    return Row()
+      .padding(16)
+      .bg('white')
+      .rounded('lg')
+      .shadow('sm')
+      .children([
+        Text(title).size(18).weight('bold').build()
+      ])
+      .build();
+  }
+);
+`;
+        await fs.writeFile(targetFile, content);
+        spinner.succeed(`Component ${chalk.green(componentName)} created successfully!`);
+        console.log(chalk.dim(`\nLocated at: ${targetFile}`));
+    }
+    catch (error) {
+        spinner.fail('Failed to create component');
+        console.error(error);
+    }
+});

package/dist/cli/commands/generate/index.js

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+import { moduleCommand } from './module';
+import { pluginCommand } from './plugin';
+import { componentCommand } from './component';
+export const generateCommand = new Command('generate')
+    .alias('g')
+    .description('Generate new architectural components (modules, plugins, etc.)')
+    .addCommand(moduleCommand)
+    .addCommand(pluginCommand)
+    .addCommand(componentCommand);

package/dist/cli/commands/generate/module.js

@@ -0,0 +1,58 @@
+import { Command } from 'commander';
+import prompts from 'prompts';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import ora from 'ora';
+export const moduleCommand = new Command('module')
+    .alias('m')
+    .description('Generate a new clean architecture module')
+    .argument('[name]', 'Name of the module')
+    .action(async (name) => {
+    let moduleName = name;
+    if (!moduleName) {
+        const response = await prompts({
+            type: 'text',
+            name: 'value',
+            message: 'What is the name of your module?',
+            validate: value => value.length < 3 ? 'Module name must be at least 3 characters' : true
+        });
+        moduleName = response.value;
+    }
+    if (!moduleName)
+        process.exit(1);
+    const spinner = ora(`Scaffolding module ${chalk.bold(moduleName)}...`).start();
+    // Normalize path: assume we are in project root or src
+    const targetDir = path.resolve(process.cwd(), 'src/modules', moduleName);
+    try {
+        if (await fs.pathExists(targetDir)) {
+            spinner.fail(`Module ${moduleName} already exists at ${targetDir}`);
+            return;
+        }
+        await fs.ensureDir(targetDir);
+        // 1. Domain Layer
+        await fs.ensureDir(path.join(targetDir, 'domain/entities'));
+        await fs.ensureDir(path.join(targetDir, 'domain/repositories'));
+        await fs.writeFile(path.join(targetDir, 'domain/entities', `${moduleName}.entity.ts`), `export interface ${capitalize(moduleName)} {\n  id: string;\n  // Add properties\n}\n`);
+        await fs.writeFile(path.join(targetDir, 'domain/repositories', `${moduleName}.repository.ts`), `import { ${capitalize(moduleName)} } from '../entities/${moduleName}.entity';\n\nexport interface I${capitalize(moduleName)}Repository {\n  getAll(): Promise<${capitalize(moduleName)}[]>;\n  getById(id: string): Promise<${capitalize(moduleName)} | null>;\n}\n`);
+        // 2. Application Layer (Use Cases)
+        await fs.ensureDir(path.join(targetDir, 'application/usecases'));
+        await fs.writeFile(path.join(targetDir, 'application/usecases', `Get${capitalize(moduleName)}.usecase.ts`), `import { I${capitalize(moduleName)}Repository } from '../../domain/repositories/${moduleName}.repository';\n\nexport class Get${capitalize(moduleName)}UseCase {\n  constructor(private repo: I${capitalize(moduleName)}Repository) {}\n\n  async execute() {\n    return this.repo.getAll();\n  }\n}\n`);
+        // 3. Infrastructure Layer
+        await fs.ensureDir(path.join(targetDir, 'infrastructure/api'));
+        await fs.writeFile(path.join(targetDir, 'infrastructure/api', `${moduleName}.api.ts`), `import { I${capitalize(moduleName)}Repository } from '../../domain/repositories/${moduleName}.repository';\nimport { ${capitalize(moduleName)} } from '../../domain/entities/${moduleName}.entity';\n\nexport class ${capitalize(moduleName)}ApiRepository implements I${capitalize(moduleName)}Repository {\n  async getAll(): Promise<${capitalize(moduleName)}[]> {\n    // Implement API call\n    return [];\n  }\n\n  async getById(id: string): Promise<${capitalize(moduleName)} | null> {\n    return null;\n  }\n}\n`);
+        // 4. Presentation Layer (UI)
+        await fs.ensureDir(path.join(targetDir, 'presentation/components'));
+        await fs.ensureDir(path.join(targetDir, 'presentation/pages'));
+        await fs.writeFile(path.join(targetDir, 'presentation/pages', `${capitalize(moduleName)}Page.tsx`), `import React from 'react';\nimport { Column, Text, FiboBuilder } from 'fiboui';\n\nexport const ${capitalize(moduleName)}Page = () => \n  Column()\n    .center()\n    .gap(20)\n    .children([\n      Text('${capitalize(moduleName)} Module').size(24).weight('bold').build()\n    ])\n    .build();\n`);
+        spinner.succeed(`Module ${chalk.green(moduleName)} created successfully!`);
+        console.log(chalk.dim(`\nLocated at: ${targetDir}`));
+    }
+    catch (error) {
+        spinner.fail('Failed to create module');
+        console.error(error);
+    }
+});
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/dist/cli/commands/generate/plugin.js

@@ -0,0 +1,67 @@
+import { Command } from 'commander';
+import prompts from 'prompts';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import ora from 'ora';
+export const pluginCommand = new Command('plugin')
+    .alias('p')
+    .description('Generate a new FiboUI plugin')
+    .argument('[name]', 'Name of the plugin')
+    .action(async (name) => {
+    let pluginName = name;
+    if (!pluginName) {
+        const response = await prompts({
+            type: 'text',
+            name: 'value',
+            message: 'What is the name of your Plugin?',
+            validate: value => value.length < 3 ? 'Plugin name must be at least 3 characters' : true
+        });
+        pluginName = response.value;
+    }
+    if (!pluginName)
+        process.exit(1);
+    const safeName = pluginName.endsWith('Plugin') ? pluginName : `${pluginName}Plugin`;
+    const spinner = ora(`Scaffolding plugin ${chalk.bold(safeName)}...`).start();
+    const targetDir = path.resolve(process.cwd(), 'src/plugins');
+    const targetFile = path.resolve(targetDir, `${safeName}.ts`);
+    try {
+        await fs.ensureDir(targetDir);
+        if (await fs.pathExists(targetFile)) {
+            spinner.fail(`Plugin ${safeName} already exists at ${targetFile}`);
+            return;
+        }
+        const content = `import { FiboPlugin, FiboContext, Card, Text, Icon } from 'fiboui';
+import { Settings } from 'lucide-react';
+
+export const ${safeName}: FiboPlugin = {
+  name: '${safeName}',
+  version: '1.0.0',
+  setup: (ctx: FiboContext) => {
+    console.log('Initializing ${safeName}...');
+
+    // Example: Register Sidebar Item
+    ctx.registerSidebarItem({
+      label: '${pluginName.replace('Plugin', '')}',
+      path: '/${pluginName.toLowerCase().replace('plugin', '')}',
+      icon: Settings, // Example icon
+      order: 10
+    });
+
+    // Example: Register an Overlay
+    // ctx.registerOverlay(() => 
+    //   Card().padding(10).children([ Text('Hello from ${safeName}').build() ]).build()
+    // );
+  }
+};
+`;
+        await fs.writeFile(targetFile, content);
+        spinner.succeed(`Plugin ${chalk.green(safeName)} created successfully!`);
+        console.log(chalk.dim(`\nLocated at: ${targetFile}`));
+        console.log(chalk.blue(`\nNext step: Register it in your main.tsx using .plugins([${safeName}])`));
+    }
+    catch (error) {
+        spinner.fail('Failed to create plugin');
+        console.error(error);
+    }
+});

package/dist/cli/commands/init.js

@@ -0,0 +1,58 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import ora from 'ora';
+export const initCommand = new Command('init')
+    .description('Initialize FiboUI configuration')
+    .action(async () => {
+    const spinner = ora('Checking project structure...').start();
+    const configPath = path.resolve(process.cwd(), 'fibo.config.js'); // Keeping it JS for wider compatibility or TS? User asked for ts.
+    if (await fs.pathExists(configPath)) {
+        spinner.fail('fibo.config.js already exists.');
+        return;
+    }
+    // Heuristics for standard architecture
+    const hasModules = await fs.pathExists(path.resolve(process.cwd(), 'src/modules'));
+    const hasPlugins = await fs.pathExists(path.resolve(process.cwd(), 'src/plugins'));
+    const hasComponents = await fs.pathExists(path.resolve(process.cwd(), 'src/components'));
+    const isStandard = hasModules && hasPlugins && hasComponents;
+    let configContent = '';
+    if (isStandard) {
+        spinner.succeed('Standard FiboUI architecture detected.');
+        configContent = `/** @type {import('fiboui').FiboConfig} */
+module.exports = {
+  paths: {
+    modules: 'src/modules',
+    plugins: 'src/plugins',
+    components: 'src/components',
+    core: 'src/core'
+  },
+  architecture: 'clean'
+};
+`;
+    }
+    else {
+        spinner.warn('Standard architecture NOT detected.');
+        console.log(chalk.yellow('Creating configuration with default/empty values. Please update "fibo.config.js" with your project paths.'));
+        configContent = `/** @type {import('fiboui').FiboConfig} */
+module.exports = {
+  paths: {
+    modules: 'src/modules', // Update this
+    plugins: 'src/plugins', // Update this
+    components: 'src/components', // Update this
+    core: 'src/core' // Update this
+  },
+  architecture: 'custom'
+};
+`;
+    }
+    try {
+        await fs.writeFile(configPath, configContent);
+        console.log(chalk.green(`\n✔ Created ${chalk.bold('fibo.config.js')}`));
+        console.log(chalk.dim('You can now generate components using your custom structure.'));
+    }
+    catch (error) {
+        console.error(chalk.red('Failed to write config file.'), error);
+    }
+});

package/dist/content.js

@@ -0,0 +1,17 @@
+"use client";
+import { b as s, A as r, B as o, I as t, c as n, L as I, P as g, a as l, S as m } from "./index-Dm4j2mMM.js";
+import { T as x } from "./index-CTRZRn9S.js";
+import { I as f } from "./index-RbfIZuAo.js";
+export {
+  s as Alert,
+  r as Avatar,
+  o as Badge,
+  f as Icon,
+  t as Image,
+  n as Integration,
+  I as Label,
+  g as Progress,
+  l as Skeleton,
+  m as Spinner,
+  x as Text
+};

package/dist/core.js

@@ -0,0 +1,33 @@
+"use client";
+import { C as s, O as r, d as t, P as o, R as i, S as u, V as p, f as l, c as b, b as n, a as c, g as d, o as v, r as S, s as m, u as R, e as g } from "./builder-DjLYXkXu.js";
+import { d as x, F as f, c as y, m as O, t as B, b as C, a as P, u as A } from "./mount-sAVX_FBU.js";
+import { F as V, b as E } from "./FineGrain-kBxv0WeR.js";
+export {
+  s as ComputedSignal,
+  x as Fibo,
+  f as FiboApp,
+  y as FiboAppBuilder,
+  V as FineGrainText,
+  r as Observable,
+  t as Observer,
+  o as ProviderWrapper,
+  i as ReactivityRoot,
+  u as Signal,
+  p as ValueBuilder,
+  l as applyResponsiveStyles,
+  E as bindText,
+  b as computed,
+  n as createReactivityRoot,
+  c as createStore,
+  d as getCurrentScope,
+  O as mount,
+  v as observable,
+  S as runInScope,
+  m as signal,
+  B as toElement,
+  R as useBuilderState,
+  C as useObservable,
+  g as useProvider,
+  P as useReactiveStore,
+  A as useSignal
+};

package/dist/{effects-D16XdB_d.mjs → effects-CnevV566.js}

@@ -1,3 +1,4 @@
+"use client";
 const c = (i, t, s = "rgba(255, 255, 255, 0.3)") => {
   if (!t) return;
   const e = document.createElement("span"), l = Math.max(t.clientWidth, t.clientHeight), n = l / 2, r = t.getBoundingClientRect();