@tixyel/cli 1.0.0 → 2.0.0

package/dist/workspace.js

@@ -0,0 +1,225 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { transform } from 'esbuild';
+import { resolve } from 'path';
+const DEFAULT_WORKSPACE_CONFIG = {
+    search: {
+        maxDepth: 3,
+        ignore: ['node_modules', 'dist', '.git', '.turbo', '.vscode'],
+    },
+    dirs: {
+        entry: 'development',
+        output: 'finished',
+        compacted: 'widgetIO',
+    },
+    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'],
+        },
+        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: {},
+            css: {
+                removeNesting: true,
+                autoprefixer: {
+                    overrideBrowserslist: ['Chrome 127'],
+                },
+                cssnano: {},
+            },
+            html: {},
+        },
+    },
+};
+// Helper to preserve literal keys for autocomplete in find/result
+export function defineWorkspaceConfig(config) {
+    config.dirs = {
+        ...DEFAULT_WORKSPACE_CONFIG.dirs,
+        ...config.dirs,
+    };
+    config.build = {
+        ...DEFAULT_WORKSPACE_CONFIG.build,
+        ...config.build,
+    };
+    config.build.find = {
+        ...DEFAULT_WORKSPACE_CONFIG.build.find,
+        ...config.build.find,
+    };
+    config.build.result = {
+        ...DEFAULT_WORKSPACE_CONFIG.build.result,
+        ...config.build.result,
+    };
+    config.search = {
+        ...DEFAULT_WORKSPACE_CONFIG.search,
+        ...config.search,
+    };
+    config.scaffold = config.scaffold || DEFAULT_WORKSPACE_CONFIG.scaffold;
+    return config;
+}
+export async function findWorkspaceRoot(startPath = process.cwd()) {
+    let currentPath = resolve(startPath);
+    // Limit search to 10 levels up to avoid infinite loops
+    for (let i = 0; i < 10; i++) {
+        const configTs = resolve(currentPath, 'tixyel.config.ts');
+        const configJs = resolve(currentPath, 'tixyel.config.js');
+        const configPathMjs = resolve(currentPath, 'tixyel.config.mjs');
+        if (existsSync(configTs) || existsSync(configJs) || existsSync(configPathMjs)) {
+            return currentPath;
+        }
+        const parentPath = resolve(currentPath, '..');
+        if (parentPath === currentPath) {
+            // Reached filesystem root
+            break;
+        }
+        currentPath = parentPath;
+    }
+    return null;
+}
+export async function validateWorkspace() {
+    const root = await findWorkspaceRoot();
+    if (!root) {
+        throw new Error('❌ Your workspace is not initialized. Please run `tixyel init` in your workspace root first.');
+    }
+    return root;
+}
+async function loadTsConfig(path, root) {
+    const temp = resolve(root, '.tixyel.config.temp.mjs');
+    const tsContent = readFileSync(path, 'utf-8');
+    const { code } = await transform(tsContent, {
+        loader: 'ts',
+        format: 'esm',
+        target: 'es2022',
+    });
+    writeFileSync(temp, code, 'utf-8');
+    try {
+        const mod = await import(`file://${temp}?t=${Date.now()}`);
+        return mod.default ?? mod.config;
+    }
+    finally {
+        try {
+            unlinkSync(temp);
+        }
+        catch { }
+    }
+}
+export async function loadWorkspace(path) {
+    const configPathTs = resolve(path, 'tixyel.config.ts');
+    const configPathJs = resolve(path, 'tixyel.config.js');
+    const configPathMjs = resolve(path, 'tixyel.config.mjs');
+    let config;
+    try {
+        // Trying .mjs first (already ES module)
+        if (existsSync(configPathMjs)) {
+            const module = await import(`file://${configPathMjs}`);
+            config = module.default || module.config;
+        }
+        // Trying .js (if package.json has type: module)
+        else if (existsSync(configPathJs)) {
+            const module = await import(`file://${configPathJs}`);
+            config = module.default || module.config;
+        }
+        // Trying .ts file (compile on-the-fly)
+        else if (existsSync(configPathTs)) {
+            config = await loadTsConfig(configPathTs, path);
+        }
+    }
+    catch (error) {
+        console.warn(`⚠️  Failed to load tixyel.config: ${error}`);
+        throw error;
+    }
+    return merge(config);
+}
+function merge(config) {
+    const merged = {
+        ...config,
+        search: {
+            ...DEFAULT_WORKSPACE_CONFIG.search,
+            ...config?.search,
+        },
+        metadata: {
+            ...DEFAULT_WORKSPACE_CONFIG.metadata,
+            ...config?.metadata,
+        },
+        dirs: {
+            ...DEFAULT_WORKSPACE_CONFIG.dirs,
+            ...config?.dirs,
+        },
+        scaffold: config?.scaffold || DEFAULT_WORKSPACE_CONFIG.scaffold,
+        build: {
+            ...DEFAULT_WORKSPACE_CONFIG.build,
+            ...config?.build,
+            find: {
+                ...DEFAULT_WORKSPACE_CONFIG.build.find,
+                ...config?.build?.find,
+            },
+            result: {
+                ...DEFAULT_WORKSPACE_CONFIG.build.result,
+                ...config?.build?.result,
+            },
+            widgetIO: {
+                ...DEFAULT_WORKSPACE_CONFIG.build.widgetIO,
+                ...config?.build?.widgetIO,
+            },
+            obfuscation: {
+                ...DEFAULT_WORKSPACE_CONFIG.build.obfuscation,
+                ...config?.build?.obfuscation,
+            },
+        },
+    };
+    return merged;
+}

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "@tixyel/cli",
-  "version": "1.0.0",
-  "description": "CLI tool for Tixyel widgets",
+  "version": "2.0.0",
+  "description": "CLI tool for streamelements widgets",
   "keywords": [
     "cli",
     "widgets",
-    "typescript"
+    "typescript",
+    "server",
+    "build"
   ],
-  "author": "Tixyel",
+  "author": {
+    "name": "Tixyel",
+    "email": "tixyelpvd@gmail.com",
+    "url": "https://github.com/tixyel"
+  },
   "license": "Apache-2.0",
   "homepage": "https://github.com/Tixyel/widgets#readme",
   "repository": {
@@ -33,30 +39,27 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "package.json"
   ],
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
+    "build": "cross-env TIXYEL_VERSION=$npm_package_version tsc",
+    "dev": "cross-env TIXYEL_VERSION=$npm_package_version tsc --watch",
     "check-types": "tsc --noEmit"
   },
-  "devDependencies": {
-    "@types/inquirer": "^9.0.9",
-    "@types/node": "^22.19.1",
-    "typescript": "^5.9.3"
-  },
   "dependencies": {
-    "@types/html-minifier-terser": "^7.0.2",
     "autoprefixer": "^10.4.22",
     "commander": "^14.0.2",
+    "cross-env": "^10.1.0",
     "cssnano": "^7.1.2",
     "fast-glob": "^3.3.3",
-    "html-minifier": "^4.0.0",
     "html-minifier-terser": "^7.2.0",
     "inquirer": "^13.0.2",
     "javascript-obfuscator": "^4.1.1",
     "jsonc-parser": "^3.3.1",
-    "postcss": "^8.5.6",
-    "postcss-nested": "^7.0.2"
+    "jszip": "^3.10.1"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9"
   }
 }

package/dist/commands/base.d.ts

@@ -1,24 +0,0 @@
-import type { Command as CommanderCommand } from 'commander';
-/**
- * Base class for all CLI commands
- */
-export declare abstract class Command {
-    /**
-     * Command name (e.g., 'init', 'build', 'generate')
-     */
-    abstract name: string;
-    /**
-     * Command description
-     */
-    abstract description: string;
-    /**
-     * Register the command with commander
-     * Override to add custom arguments/options
-     */
-    register(command: CommanderCommand): void;
-    /**
-     * Execute the command
-     * Implement in subclasses
-     */
-    abstract execute(...args: unknown[]): Promise<void>;
-}

package/dist/commands/base.js

@@ -1,15 +0,0 @@
-/**
- * Base class for all CLI commands
- */
-export class Command {
-    /**
-     * Register the command with commander
-     * Override to add custom arguments/options
-     */
-    register(command) {
-        command
-            .command(this.name)
-            .description(this.description)
-            .action((...args) => this.execute(...args));
-    }
-}

package/dist/commands/build.d.ts

@@ -1,15 +0,0 @@
-import type { Command as CommanderCommand } from 'commander';
-import { Command } from './base.js';
-/**
- * Build command
- */
-export declare class BuildCommand extends Command {
-    name: string;
-    description: string;
-    register(command: CommanderCommand): void;
-    execute(options?: {
-        depth?: string;
-        parallel?: boolean;
-        verbose?: boolean;
-    }): Promise<void>;
-}

package/dist/commands/build.js

@@ -1,155 +0,0 @@
-import inquirer from 'inquirer';
-import { findWidgets } from '../utils/find-widgets.js';
-import { bumpWidgetVersion } from '../utils/version.js';
-import { loadCliConfig } from '../utils/load-cli-config.js';
-import { validateWorkspaceInit } from '../utils/workspace.js';
-import { buildWidget as processBuild } from '../utils/build-processor.js';
-import { Command } from './base.js';
-/**
- * Build command
- */
-export class BuildCommand extends Command {
-    constructor() {
-        super(...arguments);
-        this.name = 'build';
-        this.description = 'Build widgets from the workspace';
-    }
-    register(command) {
-        command
-            .command(this.name)
-            .description(this.description)
-            .option('-d, --depth <number>', 'Maximum depth to search for widgets', '3')
-            .option('-p, --parallel', 'Build widgets in parallel')
-            .option('-v, --verbose', 'Show verbose output')
-            .action((...args) => this.execute(...args));
-    }
-    async execute(options = {}) {
-        try {
-            // Validate workspace is initialized
-            const workspaceRoot = await validateWorkspaceInit();
-            const rootPath = process.cwd();
-            // Load CLI config from workspace root
-            const cliConfig = await loadCliConfig(workspaceRoot);
-            const maxDepth = options.depth ? parseInt(options.depth, 10) : cliConfig.search.maxDepth;
-            console.log(`🔍 Searching for widgets (max depth: ${maxDepth})...\n`);
-            // Find all widgets
-            const widgets = await findWidgets(rootPath, maxDepth, cliConfig.search.ignore);
-            if (widgets.length === 0) {
-                console.log('❌ No widgets found with .tixyel configuration files.');
-                return;
-            }
-            console.log(`✅ Found ${widgets.length} widget(s)\n`);
-            // Create choices for selection
-            const choices = widgets.map((widget) => ({
-                name: `${widget.config.name} (${widget.relativePath})`,
-                value: widget.path,
-                checked: false,
-            }));
-            let selectedPaths = [];
-            if (choices.length === 1) {
-                selectedPaths = [choices[0].value];
-                console.log(`🔒 Only one widget found, auto-selected: ${choices[0].name}\n`);
-            }
-            else {
-                // Prompt for widget selection
-                const answers = await inquirer.prompt([
-                    {
-                        type: 'checkbox',
-                        name: 'selectedWidgets',
-                        message: 'Select widgets to build:',
-                        choices,
-                        pageSize: 10,
-                        loop: false,
-                    },
-                ]);
-                selectedPaths = answers.selectedWidgets;
-            }
-            if (selectedPaths.length === 0) {
-                console.log('\n⚠️  No widgets selected. Exiting...');
-                return;
-            }
-            // Prompt for version bump
-            const versionAnswers = await inquirer.prompt([
-                {
-                    type: 'select',
-                    name: 'versionBump',
-                    message: 'Version bump type:',
-                    choices: [
-                        { name: 'No version bump', value: 'none' },
-                        { name: 'Patch (x.x.1)', value: 'patch' },
-                        { name: 'Minor (x.1.0)', value: 'minor' },
-                        { name: 'Major (1.0.0)', value: 'major' },
-                    ],
-                    default: 'none',
-                    loop: false,
-                    pageSize: 4,
-                },
-            ]);
-            const versionBump = versionAnswers.versionBump;
-            // Resolve parallel setting (CLI option overrides config)
-            const useParallel = options.parallel ?? cliConfig.build.parallel;
-            const verbose = options.verbose ?? cliConfig.build.verbose;
-            console.log(`\n🚀 Building ${selectedPaths.length} widget(s)${useParallel ? ' (parallel)' : ''}...\n`);
-            // Build each selected widget
-            if (useParallel) {
-                // Parallel execution
-                await Promise.all(selectedPaths.map(async (widgetPath) => {
-                    const widget = widgets.find((w) => w.path === widgetPath);
-                    if (widget) {
-                        await buildWidget(widget.path, widget.config.name, versionBump !== 'none' ? versionBump : undefined, verbose, widget.config, cliConfig);
-                    }
-                }));
-            }
-            else {
-                // Sequential execution
-                for (const widgetPath of selectedPaths) {
-                    const widget = widgets.find((w) => w.path === widgetPath);
-                    if (widget) {
-                        await buildWidget(widget.path, widget.config.name, versionBump !== 'none' ? versionBump : undefined, verbose, widget.config, cliConfig);
-                    }
-                }
-            }
-            console.log('\n✨ Build complete!');
-        }
-        catch (error) {
-            console.error(`${error}`);
-            process.exit(1);
-        }
-    }
-}
-/**
- * Builds a single widget
- */
-async function buildWidget(widgetPath, widgetName, versionBump, verbose, config, cliConfig) {
-    console.log(`📦 Building ${widgetName}...`);
-    if (verbose) {
-        console.log(`   Path: ${widgetPath}`);
-    }
-    // Bump version if requested
-    if (versionBump) {
-        const newVersion = await bumpWidgetVersion(widgetPath, versionBump);
-        if (newVersion) {
-            console.log(`   📌 Version bumped to: ${newVersion}`);
-        }
-    }
-    // Process build if config and cliConfig provided
-    if (config && cliConfig) {
-        try {
-            await processBuild({
-                widgetPath,
-                config,
-                cliConfig,
-                verbose,
-            });
-        }
-        catch (error) {
-            console.error(`   ❌ Build failed: ${error}`);
-            throw error;
-        }
-    }
-    else {
-        console.error('   ❌ Missing configuration for build process.');
-        throw new Error('Missing configuration for build process.');
-    }
-    console.log(`✓ ${widgetName} built successfully\n`);
-}

package/dist/commands/generate-new.d.ts

@@ -1,11 +0,0 @@
-/**
- * Generate command handler
- *
- * Usage:
- * - `tixyel generate` -> creates widget in current directory (01 - Widget)
- * - `tixyel generate widgets` -> creates widgets/01 - Widget/
- * - `tixyel generate widgets myname` -> creates widgets/myname/
- * - `tixyel generate widgets/` -> creates widget at widgets/
- * - All parameters except path are optional and can be provided via prompts
- */
-export declare function generateCommand(targetPath?: string, widgetName?: string, description?: string, tags?: string): Promise<void>;

package/dist/commands/generate-new.js

@@ -1,146 +0,0 @@
-import { resolve, basename, join } from 'path';
-import { mkdir, writeFile } from 'fs/promises';
-import { existsSync } from 'fs';
-import inquirer from 'inquirer';
-import { loadCliConfig } from '../utils/load-cli-config.js';
-/**
- * Determines if a path should be treated as a parent directory or target directory
- * Paths ending with / are treated as target directories
- */
-function isTargetDirectory(path) {
-    return path.endsWith('/') || path.endsWith('\\');
-}
-/**
- * Gets the next widget number in a parent directory
- */
-async function getNextWidgetNumber(parentPath) {
-    try {
-        if (!existsSync(parentPath)) {
-            return '01';
-        }
-        // Check for existing widget folders
-        const { readdirSync } = await import('fs');
-        const entries = readdirSync(parentPath);
-        const widgetNumbers = entries
-            .filter((name) => /^\d+\s*-\s*/.test(name))
-            .map((name) => parseInt(name.split('-')[0], 10))
-            .filter((num) => !isNaN(num));
-        const maxNum = widgetNumbers.length > 0 ? Math.max(...widgetNumbers) : 0;
-        return String(maxNum + 1).padStart(2, '0');
-    }
-    catch {
-        return '01';
-    }
-}
-/**
- * Generate command handler
- *
- * Usage:
- * - `tixyel generate` -> creates widget in current directory (01 - Widget)
- * - `tixyel generate widgets` -> creates widgets/01 - Widget/
- * - `tixyel generate widgets myname` -> creates widgets/myname/
- * - `tixyel generate widgets/` -> creates widget at widgets/
- * - All parameters except path are optional and can be provided via prompts
- */
-export async function generateCommand(targetPath, widgetName, description, tags) {
-    const rootPath = process.cwd();
-    // Load CLI config
-    const cliConfig = await loadCliConfig(rootPath);
-    // Default to current directory if no path provided
-    const resolvedPath = targetPath ? resolve(rootPath, targetPath.replace(/[/\\]$/, '')) : rootPath;
-    const isTarget = targetPath ? isTargetDirectory(targetPath) : false;
-    console.log('🎨 Generating widget...\n');
-    if (isTarget) {
-        // Path ends with / -> use as target directory
-        const folderName = basename(resolvedPath);
-        await createWidget(resolvedPath, folderName, description, tags, cliConfig);
-    }
-    else {
-        // Path without / -> use as parent directory
-        let finalWidgetName = widgetName;
-        if (!finalWidgetName) {
-            // Get next number and ask for name
-            const nextNum = await getNextWidgetNumber(resolvedPath);
-            const defaultName = `${nextNum} - Widget`;
-            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, finalWidgetName, description, tags, cliConfig);
-    }
-    console.log('\n✨ Generation complete!');
-}
-/**
- * Prompts for optional widget metadata
- */
-async function promptMetadata(widgetName, initialDescription, initialTags) {
-    const answers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'description',
-            message: 'Widget description:',
-            default: initialDescription || '',
-        },
-        {
-            type: 'input',
-            name: 'tags',
-            message: 'Widget tags (comma-separated):',
-            default: initialTags || '',
-        },
-    ]);
-    const tagsArray = answers.tags
-        ? answers.tags
-            .split(',')
-            .map((tag) => tag.trim())
-            .filter((tag) => tag.length > 0)
-        : [];
-    return {
-        description: answers.description,
-        tags: tagsArray,
-    };
-}
-/**
- * Creates a widget with .tixyel configuration file
- */
-async function createWidget(widgetPath, widgetName, description, tagsStr, cliConfig) {
-    try {
-        console.log(`📁 Creating widget: ${widgetName}`);
-        console.log(`   Path: ${widgetPath}`);
-        // Create directory
-        await mkdir(widgetPath, { recursive: true });
-        // Prompt for metadata if not provided
-        const metadata = await promptMetadata(widgetName, description, tagsStr);
-        // Create .tixyel configuration
-        const tixyelConfig = {
-            name: widgetName,
-            description: metadata.description,
-            metadata: {
-                author: cliConfig?.generationDefaults.author || 'Tixyel',
-                tags: metadata.tags,
-                platform: cliConfig?.generationDefaults.platform || 'streamelements',
-            },
-        };
-        const configPath = join(widgetPath, '.tixyel');
-        await writeFile(configPath, JSON.stringify(tixyelConfig, null, 2), 'utf-8');
-        console.log(`✓ Created ${widgetName} successfully`);
-        console.log(`   - Name: ${widgetName}`);
-        if (metadata.description) {
-            console.log(`   - Description: ${metadata.description}`);
-        }
-        if (metadata.tags.length > 0) {
-            console.log(`   - Tags: ${metadata.tags.join(', ')}`);
-        }
-        console.log(`   - .tixyel configuration created`);
-    }
-    catch (error) {
-        console.error(`❌ Failed to create widget: ${error}`);
-        throw error;
-    }
-}

package/dist/commands/generate.d.ts

@@ -1,11 +0,0 @@
-import type { Command as CommanderCommand } from 'commander';
-import { Command } from './base.js';
-/**
- * Generate command
- */
-export declare class GenerateCommand extends Command {
-    name: string;
-    description: string;
-    register(command: CommanderCommand): void;
-    execute(targetPath?: string, widgetName?: string, description?: string, tags?: string): Promise<void>;
-}