@tixyel/cli 2.7.0 → 3.0.0

package/dist/index.js

@@ -1,416 +0,0 @@
-#!/usr/bin/env node
-import { Command as Commander } from 'commander';
-import { basename, join, resolve } from 'path';
-import { writeFile } from 'fs/promises';
-import { createRequire } from 'module';
-const program = new Commander();
-program
-    .name('tixyel')
-    .description('CLI tool for streamelements widgets')
-    .version((() => {
-    try {
-        const require = createRequire(import.meta.url);
-        const { version } = require('../package.json');
-        return version ?? 'dev';
-    }
-    catch {
-        return process.env.TIXYEL_VERSION ?? 'dev';
-    }
-})());
-program
-    .command('init')
-    .aliases(['initialize', 'i', 'setup', 'start'])
-    .description('Initialize a new widget workspace.')
-    .action(async () => {
-    const { workspace_config } = await import('./templates/workspace.js');
-    const root = process.cwd();
-    const config = resolve(root, 'tixyel.config.ts');
-    // Pergunta se o usuário quer instalar pacotes npm
-    const inquirer = (await import('inquirer')).default;
-    const { exec } = await import('child_process');
-    const util = await import('util');
-    const execPromise = util.promisify(exec);
-    const { installPackages } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'installPackages',
-            message: 'You want to install essential npm/bun packages?',
-            default: true,
-        },
-    ]);
-    if (installPackages) {
-        const availablesManagers = [];
-        // check if npm is available
-        const checkManager = async (manager) => {
-            try {
-                await execPromise(`${manager} --version`);
-                availablesManagers.push(manager);
-            }
-            catch {
-                // not available
-            }
-        };
-        await Promise.all(['npm', 'yarn', 'pnpm', 'bun'].map((mgr) => checkManager(mgr)));
-        var packageManager;
-        if (availablesManagers.length === 0) {
-            console.error('❌ No package managers found (npm, yarn, pnpm, bun). Please install one and try again.');
-            return;
-        }
-        else if (availablesManagers.length === 1) {
-            packageManager = availablesManagers[0];
-        }
-        else {
-            const response = await inquirer.prompt([
-                {
-                    type: 'select',
-                    name: 'packageManager',
-                    message: 'Select your package manager:',
-                    choices: availablesManagers,
-                    default: 'npm',
-                },
-            ]);
-            packageManager = response.packageManager;
-        }
-        console.log(`📦 Installing packages using ${packageManager} ...`);
-        let installCommand = '';
-        const packages = ['@tixyel/cli', '@tixyel/streamelements', 'comfy.js', 'motion', 'typescript', '@types/node', '@types/jquery', 'lottie-web'];
-        switch (packageManager) {
-            case 'npm': {
-                installCommand = `npm install ${packages.join(' ')}`;
-                break;
-            }
-            case 'yarn': {
-                installCommand = `yarn add ${packages.join(' ')}`;
-                break;
-            }
-            case 'pnpm': {
-                installCommand = `pnpm add ${packages.join(' ')}`;
-                break;
-            }
-            case 'bun': {
-                installCommand = `bun add ${packages.join(' ')}`;
-                break;
-            }
-        }
-        if (!installCommand) {
-            console.error('❌ Invalid package manager selected.');
-            return;
-        }
-        try {
-            const { stdout, stderr } = await execPromise(installCommand, { cwd: root });
-            if (stdout)
-                process.stdout.write(stdout);
-            if (stderr)
-                process.stderr.write(stderr);
-            console.log('✅ Packages installed successfully.');
-        }
-        catch (error) {
-            console.error('❌ Error installing packages:', error);
-        }
-    }
-    console.log('🚀 Initializing new workspace...');
-    console.log(`📁 Workspace root: ${root}`);
-    const content = workspace_config;
-    try {
-        await writeFile(config, content, 'utf-8');
-        console.log(`✅ Created tixyel.config.ts`);
-        console.log('   Edit it to customize your workspace settings.');
-        console.log('\n🎉 All set! Start building your widgets!');
-        console.log('   - Use "tixyel generate" to create new widgets.');
-        console.log('   - Use "tixyel build" to build your widgets for publish.');
-    }
-    catch (error) {
-        throw error;
-    }
-});
-program
-    .command('generate [path] [name] [description] [tags]')
-    .aliases(['new', 'g', 'create', 'widget'])
-    .description('Generate a new widget.')
-    .action(async (path, name, description, tags) => {
-    try {
-        const { validateWorkspace, loadWorkspace } = await import('./workspace.js');
-        const { createWidget, getNextWidgetNumber } = await import('./widget.js');
-        // Validate if the workspace is initialized
-        const validWorkspacePath = await validateWorkspace();
-        const rootPath = process.cwd();
-        // Load the workspace config
-        const workspaceConfig = await loadWorkspace(validWorkspacePath);
-        // Default to current dir if the path wasn't provided
-        const resolvedPath = path ? resolve(rootPath, path.replace(/[/\\]$/, '')) : rootPath;
-        const isTarget = path ? path.endsWith('/') || path.endsWith('\\') : false;
-        console.log('🎨 Generating widget...\n');
-        if (isTarget) {
-            // Path ends with / -> use as target directory
-            const folderName = basename(resolvedPath);
-            await createWidget(resolvedPath, {
-                name: folderName,
-                description,
-                tags: tags ? tags.split(',').map((t) => t.trim()) : undefined,
-            }, workspaceConfig, validWorkspacePath);
-        }
-        else {
-            // Path without / -> use as parent directory
-            let finalWidgetName = name;
-            if (!finalWidgetName) {
-                // Get next number and ask for name
-                const nextNum = await getNextWidgetNumber(resolvedPath);
-                const defaultName = `${nextNum} - Widget`;
-                const inquirer = (await import('inquirer')).default;
-                const answers = await inquirer.prompt([
-                    {
-                        type: 'input',
-                        name: 'name',
-                        message: 'Widget name:',
-                        default: defaultName,
-                    },
-                ]);
-                finalWidgetName = answers.name;
-            }
-            const widgetPath = join(resolvedPath, finalWidgetName);
-            await createWidget(widgetPath, {
-                name: finalWidgetName.replace(/^\d+\s*-\s*/, ''),
-                description,
-                tags: tags ? tags.split(',').map((t) => t.trim()) : undefined,
-            }, workspaceConfig, validWorkspacePath);
-        }
-        console.log('\n✨ Generation complete!');
-    }
-    catch (error) {
-        throw error;
-    }
-});
-program
-    .command('build')
-    .aliases(['b', 'compact', 'compile'])
-    .description('Build widgets in the workspace. Supports interactive selection and version bumping.')
-    .option('-d --depth <number>', 'Maximum search depth for widgets', '3')
-    .option('-p --parallel', 'Build widgets in parallel')
-    .option('-v --verbose', 'Show verbose output')
-    .option('-w --widgets <names>', 'Widget names or paths to build (comma-separated, or * for all)')
-    .option('-b --bump <type>', 'Version bump type (none, patch, minor, major)')
-    .action(async (options = {}) => {
-    try {
-        const { validateWorkspace, loadWorkspace } = await import('./workspace.js');
-        const { build, findWidgets } = await import('./widget.js');
-        let inquirer = null;
-        const getInquirer = async () => (inquirer ??= (await import('inquirer')).default);
-        // Validate if the workspace is initialized
-        const validWorkspacePath = await validateWorkspace();
-        const rootPath = process.cwd();
-        // Load the workspace config
-        const workspaceConfig = await loadWorkspace(validWorkspacePath);
-        const maxDepth = options.depth ? parseInt(options.depth, 10) : workspaceConfig.search?.maxDepth || 3;
-        console.log(`🔍 Searching for widgets (max depth: ${maxDepth})...\n`);
-        // Find all widgets on the workspace
-        const widgets = await findWidgets(rootPath, maxDepth, workspaceConfig.search?.ignore || []);
-        let selectedPaths = [];
-        if (widgets.length === 0) {
-            console.log('❌ No widgets found with .tixyel configuration files.');
-            return;
-        }
-        // Handle --widgets option
-        if (options.widgets) {
-            if (options.widgets === '*') {
-                // Select all widgets
-                selectedPaths = widgets.map((w) => w.path);
-                console.log(`✅ Auto-selected all ${widgets.length} widget(s)\n`);
-            }
-            else {
-                // Parse comma-separated widget names or paths
-                const widgetSelectors = options.widgets.split(',').map((s) => s.trim());
-                selectedPaths = widgets.filter((w) => widgetSelectors.some((sel) => w.config.name === sel || w.path.includes(sel))).map((w) => w.path);
-                if (selectedPaths.length === 0) {
-                    console.log(`❌ No widgets matched the provided names/paths: ${options.widgets}`);
-                    return;
-                }
-                console.log(`✅ Selected ${selectedPaths.length} widget(s)\n`);
-            }
-        }
-        else {
-            // Interactive mode
-            const choices = widgets.map((widget) => ({
-                name: `${widget.config.name} (${widget.relativePath})`,
-                value: widget.path,
-                checked: false,
-            }));
-            if (widgets.length === 1) {
-                selectedPaths = [choices[0].value];
-                console.log(`🔒 Only one widget found, auto-selected: ${choices[0].name}\n`);
-            }
-            else {
-                console.log(`✅ Found ${widgets.length} widget(s)\n`);
-                const inquirerInstance = await getInquirer();
-                const answers = await inquirerInstance.prompt([
-                    {
-                        type: 'checkbox',
-                        name: 'selectedWidgets',
-                        message: 'Select widgets to build:',
-                        choices,
-                        pageSize: 10,
-                        loop: false,
-                    },
-                ]);
-                selectedPaths = answers.selectedWidgets;
-            }
-        }
-        if (selectedPaths.length === 0) {
-            console.log('❌ No widgets selected for build. Exiting.');
-            return;
-        }
-        // Handle version bump
-        let versionBump = 'none';
-        if (options.bump) {
-            const validBumps = ['none', 'patch', 'minor', 'major'];
-            if (!validBumps.includes(options.bump)) {
-                console.log(`❌ Invalid version bump type: ${options.bump}. Valid options: ${validBumps.join(', ')}`);
-                return;
-            }
-            versionBump = options.bump;
-            console.log(`📌 Version bump: ${versionBump}\n`);
-        }
-        else {
-            // Interactive mode
-            const inquirerInstance = await getInquirer();
-            const versionAnswers = await inquirerInstance.prompt([
-                {
-                    type: 'select',
-                    name: 'versionBump',
-                    message: 'Select version bump type:',
-                    choices: [
-                        { name: 'No version bump', value: 'none' },
-                        { name: 'Patch (x.x.1)', value: 'patch' },
-                        { name: 'Minor (x.1.x)', value: 'minor' },
-                        { name: 'Major (1.x.x)', value: 'major' },
-                    ],
-                    default: 'none',
-                    loop: false,
-                    pageSize: 4,
-                },
-            ]);
-            versionBump = versionAnswers.versionBump;
-        }
-        // Resolve parallel option (CLI option overrides config)
-        const buildInParallel = options.parallel ?? workspaceConfig.build?.parallel ?? false;
-        const verboseOutput = options.verbose ?? workspaceConfig.build?.verbose ?? false;
-        console.log(`\n⚙️ Building ${selectedPaths.length} widget(s)${buildInParallel ? ' in parallel' : ''}...\n`);
-        if (buildInParallel) {
-            await Promise.all(selectedPaths.map(async (path) => {
-                const widget = widgets.find((w) => w.path === path);
-                if (widget) {
-                    await build(widget, versionBump, verboseOutput, workspaceConfig);
-                }
-            }));
-        }
-        else {
-            for (const widgetPath of selectedPaths) {
-                const widget = widgets.find((w) => w.path === widgetPath);
-                if (widget) {
-                    await build(widget, versionBump, verboseOutput, workspaceConfig);
-                }
-            }
-        }
-        console.log('\n🎉 Build process complete!');
-    }
-    catch (error) {
-        throw error;
-    }
-});
-program
-    .command('update')
-    .aliases(['upgrade', 'u'])
-    .description('Update Tixyel packages to the latest version.')
-    .option('-f --force', 'Force update even if already on latest version', false)
-    .option('-nc --no-cache', 'Disable package manager cache during installation', false)
-    .action(async (options) => {
-    const root = process.cwd();
-    const inquirer = (await import('inquirer')).default;
-    const { exec } = await import('child_process');
-    const util = await import('util');
-    const execPromise = util.promisify(exec);
-    const availablesManagers = [];
-    // check if npm is available
-    const checkManager = async (manager) => {
-        try {
-            await execPromise(`${manager} --version`);
-            availablesManagers.push(manager);
-        }
-        catch {
-            // not available
-        }
-    };
-    await Promise.all(['npm', 'yarn', 'pnpm', 'bun'].map((mgr) => checkManager(mgr)));
-    var packageManager;
-    if (availablesManagers.length === 0) {
-        console.error('❌ No package managers found (npm, yarn, pnpm, bun). Please install one and try again.');
-        return;
-    }
-    else if (availablesManagers.length === 1) {
-        packageManager = availablesManagers[0];
-    }
-    else {
-        const response = await inquirer.prompt([
-            {
-                type: 'select',
-                name: 'packageManager',
-                message: 'Select your package manager:',
-                choices: availablesManagers,
-                default: 'npm',
-            },
-        ]);
-        packageManager = response.packageManager;
-    }
-    console.log(`📦 Installing packages using ${packageManager} ...`);
-    let installCommand = '';
-    const packages = ['@tixyel/cli@latest', '@tixyel/streamelements@latest'];
-    switch (packageManager) {
-        case 'npm': {
-            installCommand = `npm install ${packages.join(' ')}`;
-            if (options.noCache)
-                installCommand += ' --no-cache';
-            if (options.force)
-                installCommand += ' --force';
-            break;
-        }
-        case 'yarn': {
-            installCommand = `yarn add ${packages.join(' ')}`;
-            if (options.noCache)
-                installCommand += ' --no-cache';
-            if (options.force)
-                installCommand += ' --force';
-            break;
-        }
-        case 'pnpm': {
-            installCommand = `pnpm add ${packages.join(' ')}`;
-            if (options.noCache)
-                installCommand += ' --no-cache';
-            if (options.force)
-                installCommand += ' --force';
-            break;
-        }
-        case 'bun': {
-            installCommand = `bun add ${packages.join(' ')}`;
-            if (options.noCache)
-                installCommand += ' --no-cache';
-            if (options.force)
-                installCommand += ' --force';
-            break;
-        }
-    }
-    if (!installCommand) {
-        console.error('❌ Invalid package manager selected.');
-        return;
-    }
-    try {
-        const { stdout, stderr } = await execPromise(installCommand, { cwd: root });
-        if (stdout)
-            process.stdout.write(stdout);
-        if (stderr)
-            process.stderr.write(stderr);
-        console.log('✅ Packages updated successfully.');
-    }
-    catch (error) {
-        console.error('❌ Error installing packages:', error);
-    }
-});
-program.parse();

package/dist/templates/workspace.d.ts

@@ -1 +0,0 @@
-export declare const workspace_config: string;

package/dist/templates/workspace.js

@@ -1,111 +0,0 @@
-export const workspace_config = `
-import { defineWorkspaceConfig } from '@tixyel/cli/api';
-
-export default defineWorkspaceConfig({
-  search: {
-    maxDepth: 3,
-    ignore: ['node_modules', 'dist', 'build', '.git'],
-  },
-
-  metadata: {
-    author: 'Your Name',
-    clientId: 'your-client-id',
-  },
-
-  scaffold: [
-    {
-      name: 'development',
-      type: 'folder',
-      content: [
-        {
-          name: 'index.html',
-          type: 'file',
-          content: \`\`,
-        },
-        {
-          name: 'style.css',
-          type: 'file',
-          content: \`\`,
-        },
-        {
-          name: 'script.js',
-          type: 'file',
-          content: \`\`,
-        },
-        {
-          name: 'fields.json',
-          type: 'file',
-          content: '{}',
-        },
-        {
-          name: 'data.json',
-          type: 'file',
-          content: '{}',
-        },
-      ],
-    },
-    {
-      name: 'finished',
-      type: 'folder',
-    },
-    {
-      name: 'widgetIO',
-      type: 'folder',
-    },
-  ],
-
-  build: {
-    parallel: true,
-    verbose: false,
-
-    find: {
-      html: ['index.html'],
-      script: ['script.js'],
-      css: ['style.css'],
-      fields: ['fields.json', 'fields.jsonc'],
-    },
-    result: {
-      'HTML.html': 'html',
-      'SCRIPT.js': 'script',
-      'CSS.css': 'css',
-      'FIELDS.json': 'fields',
-    },
-    widgetIO: {
-      'html.txt': 'html',
-      'js.txt': 'script',
-      'css.txt': 'css',
-      'fields.txt': 'fields',
-    },
-
-    obfuscation: {
-      javascript: {
-        compact: true,
-        log: false,
-        debugProtection: false,
-        selfDefending: false,
-        deadCodeInjection: false,
-        controlFlowFlattening: false,
-        stringArray: false,
-        simplify: false,
-        identifierNamesGenerator: 'mangled',
-      },
-      css: {
-        removeNesting: true,
-        autoprefixer: {
-          overrideBrowserslist: ['Chrome 127'],
-        },
-        cssnano: {
-          preset: 'default',
-        },
-      },
-      html: {
-        removeComments: true,
-        collapseWhitespace: true,
-        minifyCSS: true,
-        minifyJS: true,
-        removeAttributeQuotes: false,
-      },
-    },
-  },
-});
-`.trim();

package/dist/utils/watermark.d.ts

@@ -1,7 +0,0 @@
-import { WidgetInfo } from '../widget';
-export declare var logo: string;
-export declare const watermark: {
-    html(widget: WidgetInfo): string;
-    css(widget: WidgetInfo): string;
-    script(widget: WidgetInfo): string;
-};

package/dist/utils/watermark.js

@@ -1,71 +0,0 @@
-export var logo = `    ____    _     _                         _ 
-   / __ \\  | |_  (_) __  __  _   _    ___  | |
-  / / _\` | | __| | | \\ \\/ / | | | |  / _ \\ | |
- | | (_| | | |_  | |  >  <  | |_| | |  __/ | |
-  \\ \\__,_|  \\__| |_| /_/\\_\\  \\__, |  \\___| |_|
-   \\____/                    |___/\n`;
-export const watermark = {
-    html(widget) {
-        return [
-            `<!---`,
-            logo,
-            `Generated by @Tixyel Widgets SDK`,
-            `Widget name: ${widget.config.name}`,
-            `Version: ${widget.config.version}`,
-            `Description: ${widget.config.description}`,
-            `Tags: ${widget.config.metadata?.tags?.join(', ')}`,
-            `Made by: ${widget.config.metadata?.author}`,
-            widget.config.metadata?.clientId ? `Made for: ${widget.config.metadata?.clientId}` : undefined,
-            ...Object.entries(widget.config.metadata || {})
-                .filter(([key]) => !['tags', 'author', 'clientId'].includes(key))
-                .map(([key, value]) => `${key}: ${value}`),
-            ' ',
-            'DO NOT EDIT, SHARE OR DISTRIBUTE THIS CODE WITHOUT PERMISSION FROM THE AUTHOR',
-            `--->`,
-        ]
-            .filter(Boolean)
-            .join('\n');
-    },
-    css(widget) {
-        return [
-            `/**`,
-            logo,
-            `Generated by @Tixyel Widgets SDK`,
-            `Widget name: ${widget.config.name}`,
-            `Version: ${widget.config.version}`,
-            `Description: ${widget.config.description}`,
-            `Tags: ${widget.config.metadata?.tags?.join(', ')}`,
-            `Made by: ${widget.config.metadata?.author}`,
-            widget.config.metadata?.clientId ? `Made for: ${widget.config.metadata?.clientId}` : undefined,
-            ...Object.entries(widget.config.metadata || {})
-                .filter(([key]) => !['tags', 'author', 'clientId'].includes(key))
-                .map(([key, value]) => `${key}: ${value}`),
-            ' ',
-            'DO NOT EDIT, SHARE OR DISTRIBUTE THIS CODE WITHOUT PERMISSION FROM THE AUTHOR',
-            `*/`,
-        ]
-            .filter(Boolean)
-            .join('\n');
-    },
-    script(widget) {
-        return [
-            `/**`,
-            logo,
-            `Generated by @Tixyel Widgets SDK`,
-            `Widget name: ${widget.config.name}`,
-            `Version: ${widget.config.version}`,
-            `Description: ${widget.config.description}`,
-            `Tags: ${widget.config.metadata?.tags?.join(', ')}`,
-            `Made by: ${widget.config.metadata?.author}`,
-            widget.config.metadata?.clientId ? `Made for: ${widget.config.metadata?.clientId}` : undefined,
-            ...Object.entries(widget.config.metadata || {})
-                .filter(([key]) => !['tags', 'author', 'clientId'].includes(key))
-                .map(([key, value]) => `${key}: ${value}`),
-            ' ',
-            'DO NOT EDIT, SHARE OR DISTRIBUTE THIS CODE WITHOUT PERMISSION FROM THE AUTHOR',
-            `*/`,
-        ]
-            .filter(Boolean)
-            .join('\n');
-    },
-};

package/dist/widget.d.ts

@@ -1,31 +0,0 @@
-import { WorkspaceConfig } from './workspace';
-export interface DotTixyel {
-    name: string;
-    description: string;
-    version: string;
-    config?: string;
-    metadata: WorkspaceConfig['metadata'];
-    dirs: WorkspaceConfig['dirs'];
-}
-export declare function createWidget(path: string, metadata: WorkspaceConfig['metadata'], config: WorkspaceConfig, root: string): Promise<void>;
-export declare function getNextWidgetNumber(parentPath: string): Promise<string>;
-export declare function validateDotTixyel(config: DotTixyel): boolean;
-export type WidgetInfo = {
-    /**
-     * Absolute path to the widget directory
-     */
-    path: string;
-    /**
-     * Relative path from the root directory
-     */
-    relativePath: string;
-    /**
-     * Parsed .tixyel configuration
-     */
-    config: DotTixyel;
-};
-export declare function readDotTixyel(path: string): Promise<DotTixyel | null>;
-export declare function findWidgets(root: string, depth: number, ignore: string[]): Promise<WidgetInfo[]>;
-export declare function build(widget: WidgetInfo, versionBump: 'none' | 'patch' | 'minor' | 'major', verbose: boolean | undefined, workspaceConfig: WorkspaceConfig): Promise<void>;
-export declare function processBuild(widget: WidgetInfo, workspaceConfig: WorkspaceConfig, verbose?: boolean): Promise<void>;
-export declare function bumpVersion(widgetPath: string, bumpType?: 'major' | 'minor' | 'patch'): Promise<string | null>;