@tixyel/cli 2.0.2 → 2.2.0

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 #!/usr/bin/env node
 export * from './workspace.js';
+export * from './widget.js';

package/dist/index.js

@@ -1,12 +1,8 @@
 #!/usr/bin/env node
-import { build, createWidget, findWidgets, getNextWidgetNumber } from './widget.js';
-import { loadWorkspace, validateWorkspace } from './workspace.js';
-import { workspace_config } from './templates/workspace.js';
 import { Command as Commander } from 'commander';
 import { basename, join, resolve } from 'path';
 import { writeFile } from 'fs/promises';
 import { createRequire } from 'module';
-import inquirer from 'inquirer';
 const program = new Commander();
 program
     .name('tixyel')
@@ -26,6 +22,7 @@ program
     .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');
     console.log('🚀 Initializing new workspace...');
@@ -49,6 +46,8 @@ program
     .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();
@@ -74,6 +73,7 @@ program
                 // 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',
@@ -86,7 +86,7 @@ program
             }
             const widgetPath = join(resolvedPath, finalWidgetName);
             await createWidget(widgetPath, {
-                name: finalWidgetName,
+                name: finalWidgetName.replace(/^\d+\s*-\s*/, ''),
                 description,
                 tags: tags ? tags.split(',').map((t) => t.trim()) : undefined,
             }, workspaceConfig, validWorkspacePath);
@@ -104,8 +104,14 @@ program
     .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('--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();
@@ -115,55 +121,92 @@ program
         console.log(`🔍 Searching for widgets (max depth: ${maxDepth})...\n`);
         // Find all widgets on the workspace
         const widgets = await findWidgets(rootPath, maxDepth, workspaceConfig.search?.ignore || []);
-        const choices = widgets.map((widget) => ({
-            name: `${widget.config.name} (${widget.relativePath})`,
-            value: widget.path,
-            checked: false,
-        }));
         let selectedPaths = [];
         if (widgets.length === 0) {
             console.log('❌ No widgets found with .tixyel configuration files.');
             return;
         }
-        else if (widgets.length === 1) {
-            selectedPaths = [choices[0].value];
-            console.log(`🔒 Only one widget found, auto-selected: ${choices[0].name}\n`);
+        // 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 {
-            console.log(`✅ Found ${widgets.length} widget(s)\n`);
-            const answers = await inquirer.prompt([
-                {
-                    type: 'checkbox',
-                    name: 'selectedWidgets',
-                    message: 'Select widgets to build:',
-                    choices,
-                    pageSize: 10,
-                    loop: false,
-                },
-            ]);
-            selectedPaths = answers.selectedWidgets;
+            // 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;
         }
-        const versionAnswers = await inquirer.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,
-            },
-        ]);
-        const versionBump = versionAnswers.versionBump;
+        // 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;
@@ -192,3 +235,4 @@ program
 });
 program.parse();
 export * from './workspace.js';
+export * from './widget.js';

package/dist/widget.js

@@ -3,8 +3,10 @@ import { minify as minifyHTML } from 'html-minifier-terser';
 import JavaScriptObfuscator from 'javascript-obfuscator';
 import { dirname, join, relative, resolve } from 'path';
 import { readFile as readFilePromise } from 'fs/promises';
+import { renderToStaticMarkup } from 'react-dom/server';
 import { mkdir, writeFile } from 'fs/promises';
 import autoprefixer from 'autoprefixer';
+import { isValidElement } from 'react';
 import { parse } from 'jsonc-parser';
 import nested from 'postcss-nested';
 import FastGlob from 'fast-glob';
@@ -12,6 +14,7 @@ import inquirer from 'inquirer';
 import postcss from 'postcss';
 import cssnano from 'cssnano';
 import JSZip from 'jszip';
+import { transformSync } from 'esbuild';
 export async function createWidget(path, metadata, config, root) {
     try {
         console.log(`📁 Creating ${metadata?.name} at: ${path}`);
@@ -43,6 +46,17 @@ export async function createWidget(path, metadata, config, root) {
         // Create scaffold files from the workspace config
         const scaffold = config.scaffold || [];
         let created = { files: 0, folders: 0 };
+        async function serializeScaffoldContent(content) {
+            if (content === undefined || content === null)
+                return '';
+            if (typeof content === 'string')
+                return content;
+            if (isValidElement(content)) {
+                return renderToStaticMarkup(content);
+            }
+            // Fallback to string conversion for unexpected types
+            return String(content ?? '');
+        }
         async function processScaffoldItem(item, basePath) {
             const fullPath = resolve(basePath, item.name);
             if (item.type === 'folder') {
@@ -56,8 +70,8 @@ export async function createWidget(path, metadata, config, root) {
                 }
             }
             else if (item.type === 'file') {
-                // Write file
-                await writeFile(fullPath, item.content || '', 'utf-8');
+                const content = await serializeScaffoldContent(item.content);
+                await writeFile(fullPath, content, 'utf-8');
                 created.files++;
             }
         }
@@ -244,6 +258,7 @@ export async function processBuild(widget, workspaceConfig, verbose = false) {
     const findPatterns = workspaceConfig.build?.find || {
         html: ['index.html'],
         script: ['script.js'],
+        typescript: ['script.ts'],
         css: ['styles.css'],
         fields: ['fields.json'],
     };
@@ -398,6 +413,30 @@ export async function processBuild(widget, workspaceConfig, verbose = false) {
             }
             result += mergedJS.trim();
         }
+        else if (['typescript', 'ts'].some((k) => key === k)) {
+            result += watermark.script + '\n';
+            if (verbose)
+                console.log(`  - Processing TypeScript...`);
+            const files = findAndRead(entryDir, list);
+            let mergedTS = '';
+            for await (const content of files) {
+                try {
+                    const transpiled = transformSync(content, {
+                        loader: 'ts',
+                        target: 'es2021',
+                        format: 'iife',
+                    });
+                    mergedTS += transpiled.code + '\n';
+                }
+                catch (error) {
+                    console.warn(`   ⚠️  Failed to compile TypeScript: ${error}`);
+                    throw error;
+                }
+            }
+            // Obfuscate the compiled JavaScript
+            const obfuscated = JavaScriptObfuscator.obfuscate(mergedTS.trim(), workspaceConfig.build?.obfuscation?.javascript);
+            result += obfuscated.getObfuscatedCode();
+        }
         else if (['fields', 'FIELDS', 'fielddata', 'fieldData'].some((k) => key === k)) {
             if (verbose)
                 console.log(`  - Processing Json...`);

package/dist/workspace.d.ts

@@ -2,11 +2,12 @@ import type { Options as HtmlMinifierOptions } from 'html-minifier-terser';
 import type { ObfuscatorOptions } from 'javascript-obfuscator';
 import type autoprefixer from 'autoprefixer';
 import type cssnanoPlugin from 'cssnano';
+import type { JSX } from 'react';
 export type ScaffoldItem = ScaffoldFile | ScaffoldFolder;
 export interface ScaffoldFile {
     name: string;
     type: 'file';
-    content: string;
+    content: string | JSX.Element;
 }
 export interface ScaffoldFolder {
     name: string;
@@ -105,6 +106,7 @@ export interface WorkspaceConfig<Find extends BuildFindMap = BuildFindMap> {
 type BuildFindMap = Record<string, string[]>;
 type BuildResultMap<Find extends BuildFindMap> = Record<string, keyof Find>;
 export declare function defineWorkspaceConfig<const Find extends BuildFindMap>(config: WorkspaceConfig<Find>): WorkspaceConfig<Find>;
+export declare function resolveConfig(path: string): Promise<WorkspaceConfig>;
 export declare function findWorkspaceRoot(startPath?: string): Promise<string | null>;
 export declare function validateWorkspace(): Promise<string>;
 export declare function loadWorkspace(path: string): Promise<WorkspaceConfig<BuildFindMap>>;

package/dist/workspace.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { extname, resolve } from 'path';
 import { transform } from 'esbuild';
-import { resolve } from 'path';
 const DEFAULT_WORKSPACE_CONFIG = {
     search: {
         maxDepth: 3,
@@ -111,14 +111,51 @@ export function defineWorkspaceConfig(config) {
     config.scaffold = config.scaffold || DEFAULT_WORKSPACE_CONFIG.scaffold;
     return config;
 }
+export async function resolveConfig(path) {
+    const configTs = resolve(path, 'tixyel.config.ts');
+    const configTsx = resolve(path, 'tixyel.config.tsx');
+    const configJs = resolve(path, 'tixyel.config.js');
+    const configJsx = resolve(path, 'tixyel.config.jsx');
+    const configMjs = resolve(path, 'tixyel.config.mjs');
+    let config;
+    try {
+        // Trying .mjs first (already ES module)
+        if (existsSync(configMjs)) {
+            const module = await import(`file://${configMjs}`);
+            config = module.default || module.config;
+        }
+        // Trying .js/.jsx (if package.json has type: module)
+        else if (existsSync(configJs)) {
+            const module = await import(`file://${configJs}`);
+            config = module.default || module.config;
+        }
+        else if (existsSync(configJsx)) {
+            config = await loadTsConfig(configJsx, path);
+        }
+        // Trying .ts/.tsx file (compile on-the-fly)
+        else if (existsSync(configTs)) {
+            config = await loadTsConfig(configTs, path);
+        }
+        else if (existsSync(configTsx)) {
+            config = await loadTsConfig(configTsx, path);
+        }
+    }
+    catch (error) {
+        console.warn(`⚠️  Failed to load tixyel.config: ${error}`);
+        throw error;
+    }
+    return merge(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 configTsx = resolve(currentPath, 'tixyel.config.tsx');
         const configJs = resolve(currentPath, 'tixyel.config.js');
+        const configJsx = resolve(currentPath, 'tixyel.config.jsx');
         const configPathMjs = resolve(currentPath, 'tixyel.config.mjs');
-        if (existsSync(configTs) || existsSync(configJs) || existsSync(configPathMjs)) {
+        if (existsSync(configTs) || existsSync(configTsx) || existsSync(configJs) || existsSync(configJsx) || existsSync(configPathMjs)) {
             return currentPath;
         }
         const parentPath = resolve(currentPath, '..');
@@ -140,10 +177,13 @@ export async function validateWorkspace() {
 async function loadTsConfig(path, root) {
     const temp = resolve(root, '.tixyel.config.temp.mjs');
     const tsContent = readFileSync(path, 'utf-8');
+    const extension = extname(path).toLowerCase();
+    const loader = extension === '.tsx' ? 'tsx' : extension === '.jsx' ? 'jsx' : 'ts';
     const { code } = await transform(tsContent, {
-        loader: 'ts',
+        loader,
         format: 'esm',
         target: 'es2022',
+        ...(loader === 'tsx' || loader === 'jsx' ? { jsx: 'automatic' } : {}),
     });
     writeFileSync(temp, code, 'utf-8');
     try {
@@ -158,31 +198,7 @@ async function loadTsConfig(path, root) {
     }
 }
 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);
+    return resolveConfig(path);
 }
 function merge(config) {
     const merged = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tixyel/cli",
-  "version": "2.0.2",
+  "version": "2.2.0",
   "description": "CLI tool for streamelements widgets",
   "keywords": [
     "cli",
@@ -54,18 +54,25 @@
     "cssnano": "^7.1.2",
     "esbuild": "^0.25.12",
     "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",
+    "javascript-obfuscator": "4.1.1",
     "jsonc-parser": "^3.3.1",
     "jszip": "^3.10.1",
     "postcss": "^8.5.6",
-    "postcss-nested": "^7.0.2"
+    "postcss-nested": "^7.0.2",
+    "react": "^19.2.1",
+    "react-dom": "^19.2.1"
   },
   "devDependencies": {
     "@types/html-minifier": "^4.0.6",
     "@types/html-minifier-terser": "^7.0.2",
-    "@types/inquirer": "^9.0.9"
+    "@types/inquirer": "^9.0.9",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
   }
 }