@tixyel/cli 1.0.0 → 2.0.1

package/dist/widget.js

@@ -0,0 +1,499 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs';
+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 { mkdir, writeFile } from 'fs/promises';
+import autoprefixer from 'autoprefixer';
+import { parse } from 'jsonc-parser';
+import nested from 'postcss-nested';
+import FastGlob from 'fast-glob';
+import inquirer from 'inquirer';
+import postcss from 'postcss';
+import cssnano from 'cssnano';
+import JSZip from 'jszip';
+export async function createWidget(path, metadata, config, root) {
+    try {
+        console.log(`📁 Creating ${metadata?.name} at: ${path}`);
+        // Create directory
+        await mkdir(path, { recursive: true });
+        // Calculate config path if workspace root is provided
+        const configPath = root ? getConfigPathFromWidget(path, root) : undefined;
+        // Prompt for metadata if not provided
+        const widgetMetadata = await getMetadata(metadata);
+        // Create .tixyel configuration
+        const dotTixyel = {
+            name: metadata?.name,
+            version: '0.0.0',
+            description: widgetMetadata?.description || '',
+            config: configPath,
+            metadata: {
+                ...config.metadata,
+                ...widgetMetadata,
+                name: undefined,
+                description: undefined,
+            },
+            dirs: config.dirs || {
+                entry: 'development',
+                output: 'finished',
+                compacted: 'compacted',
+            },
+        };
+        await writeFile(resolve(path, '.tixyel'), JSON.stringify(dotTixyel, null, 2), 'utf-8');
+        // Create scaffold files from the workspace config
+        const scaffold = config.scaffold || [];
+        let created = { files: 0, folders: 0 };
+        async function processScaffoldItem(item, basePath) {
+            const fullPath = resolve(basePath, item.name);
+            if (item.type === 'folder') {
+                await mkdir(fullPath, { recursive: true });
+                created.folders++;
+                // Process folder children if any
+                if (item.content && Array.isArray(item.content) && item.content.length) {
+                    for (const child of item.content) {
+                        await processScaffoldItem(child, fullPath);
+                    }
+                }
+            }
+            else if (item.type === 'file') {
+                // Write file
+                await writeFile(fullPath, item.content || '', 'utf-8');
+                created.files++;
+            }
+        }
+        for (const item of scaffold) {
+            await processScaffoldItem(item, path);
+        }
+        console.log(`✅ Widget ${dotTixyel.name} created successfully!`);
+        if (dotTixyel.description && dotTixyel.description.length) {
+            console.log(`  - Description: ${dotTixyel.description}`);
+        }
+        if (dotTixyel.metadata?.tags && dotTixyel.metadata?.tags.length) {
+            console.log(`  - Tags: ${dotTixyel.metadata.tags.join(', ')}`);
+        }
+        if (dotTixyel.config) {
+            console.log(`  - Config Path: ${dotTixyel.config}`);
+        }
+        if (created.folders > 0 || created.files > 0) {
+            console.log(`  - Scaffolded: ${created.folders} folders, ${created.files} files`);
+        }
+    }
+    catch (error) {
+        console.error('❌ Failed to create widget:', error);
+        throw error;
+    }
+}
+async function getMetadata(existingMetadata) {
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Widget description:',
+            default: existingMetadata?.description || '',
+        },
+        {
+            type: 'input',
+            name: 'tags',
+            message: 'Widget tags (comma-separated):',
+            default: existingMetadata?.tags ? existingMetadata.tags.join(', ') : '',
+        },
+    ]);
+    const tagsArray = answers.tags
+        ? answers.tags
+            .split(',')
+            .map((tag) => tag.trim())
+            .filter((tag) => tag.length)
+        : [];
+    return {
+        description: answers.description,
+        tags: tagsArray,
+    };
+}
+function getConfigPathFromWidget(widgetPath, workspaceRoot) {
+    const configTs = resolve(workspaceRoot, 'tixyel.config.ts');
+    const configJs = resolve(workspaceRoot, 'tixyel.config.js');
+    const configPathMjs = resolve(workspaceRoot, 'tixyel.config.mjs');
+    const targetConfig = existsSync(configTs) ? configTs : existsSync(configJs) ? configJs : existsSync(configPathMjs) ? configPathMjs : null;
+    if (!targetConfig) {
+        throw new Error('❌ Workspace configuration file not found.');
+    }
+    const relativePath = relative(widgetPath, targetConfig);
+    const normalized = relativePath.replace(/\\/g, '/');
+    return normalized.startsWith('.') ? normalized : `./${normalized}`;
+}
+export async function getNextWidgetNumber(parentPath) {
+    try {
+        if (!existsSync(parentPath)) {
+            return '01';
+        }
+        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 (error) {
+        return '01';
+    }
+}
+async function merge(config) {
+    const merged = {
+        ...config,
+        version: config.version || '0.0.0',
+        description: config.description || '',
+        metadata: {
+            ...config.metadata,
+        },
+        dirs: {
+            entry: 'development',
+            output: 'finished',
+            compacted: 'compacted',
+            ...config.dirs,
+        },
+    };
+    return merged;
+}
+export function validateDotTixyel(config) {
+    if (typeof config !== 'object' || !config || config === null || !config.name || typeof config.name !== 'string' || !config.name.trim().length) {
+        throw new Error('❌ Invalid .tixyel: "name" is required and must be a non-empty string.');
+    }
+    return true;
+}
+export async function readDotTixyel(path) {
+    try {
+        const dotTixyelPath = resolve(path, '.tixyel');
+        if (!existsSync(dotTixyelPath)) {
+            return null;
+        }
+        const content = await readFilePromise(dotTixyelPath, 'utf-8');
+        const config = parse(content);
+        if (!validateDotTixyel(config)) {
+            console.error(`Invalid .tixyel configuration in ${path}`);
+            return null;
+        }
+        return merge(config);
+    }
+    catch (error) {
+        return null;
+    }
+}
+export async function findWidgets(root, depth, ignore) {
+    // Build glob pattern with depth limit
+    const depthPattern = Array.from({ length: depth }, (_, i) => '*'.repeat(i + 1)).join(',');
+    const pattern = `{${depthPattern}}/.tixyel`;
+    // Build ignore patterns (folders and files)
+    const ignorePatterns = ['node_modules', '.git', 'dist', ...ignore];
+    // Find all .tixyel files
+    const dotTixyels = await FastGlob(pattern, {
+        cwd: root,
+        absolute: true,
+        onlyFiles: true,
+        ignore: ignorePatterns,
+    });
+    const widgets = [];
+    for (const dotTixyelPath of dotTixyels) {
+        const path = dirname(dotTixyelPath);
+        const config = await readDotTixyel(path);
+        if (config) {
+            widgets.push({
+                path,
+                relativePath: relative(root, path),
+                config,
+            });
+        }
+    }
+    return widgets;
+}
+export async function build(widget, versionBump, verbose = false, workspaceConfig) {
+    console.log(`🔨 Building widget: ${widget.config.name}`);
+    if (verbose) {
+        console.log(`   - Path: ${widget.path}`);
+    }
+    if (versionBump !== 'none') {
+        const newVersion = await bumpVersion(widget.path, versionBump);
+        if (newVersion) {
+            console.log(`   - Bumped version to: ${newVersion}`);
+            widget.config.version = newVersion;
+        }
+    }
+    if (widget.config && workspaceConfig) {
+        try {
+            await processBuild(widget, workspaceConfig, verbose);
+        }
+        catch (error) {
+            console.error(`❌ Build failed for widget ${widget.config.name}:`, error);
+            throw error;
+        }
+    }
+    else {
+        console.warn(`⚠️ Skipping build for widget ${widget.config.name}: Missing configuration.`);
+        throw new Error('Missing configuration for build process.');
+    }
+    console.log(`✅ Build completed for widget: ${widget.config.name}`);
+}
+export async function processBuild(widget, workspaceConfig, verbose = false) {
+    const entryDir = join(widget.path, widget.config.dirs?.entry || workspaceConfig.dirs?.entry || 'development');
+    const outDir = join(widget.path, widget.config.dirs?.output || workspaceConfig.dirs?.output || 'finished');
+    const compactedDir = join(widget.path, widget.config.dirs?.compacted || workspaceConfig.dirs?.compacted || 'widgetIO');
+    if (!existsSync(entryDir)) {
+        throw new Error(`Entry directory not found: ${entryDir}`);
+    }
+    mkdirSync(outDir, { recursive: true });
+    const findPatterns = workspaceConfig.build?.find || {
+        html: ['index.html'],
+        script: ['script.js'],
+        css: ['styles.css'],
+        fields: ['fields.json'],
+    };
+    const resultMapping = workspaceConfig.build?.result || {
+        'HTML.html': 'html',
+        'SCRIPT.js': 'script',
+        'CSS.css': 'css',
+        'FIELDS.json': 'fields',
+    };
+    const compactedMapping = workspaceConfig.build?.widgetIO || {
+        'html.txt': 'html',
+        'js.txt': 'script',
+        'css.txt': 'css',
+        'fields.txt': 'fields',
+    };
+    // const results: Record<string, string> = {};
+    const normalizeList = (value) => (Array.isArray(value) ? value.filter(Boolean) : []);
+    const findAndRead = (baseDir, patterns) => {
+        const contents = [];
+        for (const pattern of patterns) {
+            const fullPath = join(baseDir, pattern);
+            if (existsSync(fullPath)) {
+                const content = readFileSync(fullPath, 'utf-8');
+                contents.push(content);
+            }
+        }
+        return contents;
+    };
+    // watermark for the files
+    var ref = `    ____    _     _                         _ 
+   / __ \\  | |_  (_) __  __  _   _    ___  | |
+  / / _\` | | __| | | \\ \\/ / | | | |  / _ \\ | |
+ | | (_| | | |_  | |  >  <  | |_| | |  __/ | |
+  \\ \\__,_|  \\__| |_| /_/\\_\\  \\__, |  \\___| |_|
+   \\____/                    |___/\n`;
+    var watermark = {
+        html: [
+            `<!---`,
+            ref,
+            `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,
+            ' ',
+            'DO NOT EDIT, SHARE OR DISTRIBUTE THIS CODE WITHOUT PERMISSION FROM THE AUTHOR',
+            `--->`,
+        ]
+            .filter(Boolean)
+            .join('\n'),
+        css: [
+            `/**`,
+            ref,
+            `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,
+            ' ',
+            'DO NOT EDIT, SHARE OR DISTRIBUTE THIS CODE WITHOUT PERMISSION FROM THE AUTHOR',
+            `*/`,
+        ]
+            .filter(Boolean)
+            .join('\n'),
+        script: [
+            `/**`,
+            ref,
+            `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,
+            ' ',
+            'DO NOT EDIT, SHARE OR DISTRIBUTE THIS CODE WITHOUT PERMISSION FROM THE AUTHOR',
+            `*/`,
+        ]
+            .filter(Boolean)
+            .join('\n'),
+    };
+    const results = Object.fromEntries(await Promise.all(Object.entries(findPatterns).map(async ([key, patterns]) => {
+        let result = '';
+        const list = normalizeList(patterns);
+        if (list.length === 0) {
+            return [key, ''];
+        }
+        // Process HTML
+        if (['html', 'HTML'].some((k) => key === k)) {
+            result += watermark.html + '\n';
+            if (verbose)
+                console.log(`  - Processing HTML...`);
+            const files = findAndRead(entryDir, list);
+            let mergedHTML = '';
+            for await (const fileContent of files) {
+                // Extract body content
+                const bodyMatch = fileContent.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
+                if (bodyMatch && bodyMatch[1]) {
+                    mergedHTML += bodyMatch[1].trim() + '\n';
+                }
+                // Extract and inline styles
+                const styleMatches = fileContent.matchAll(/<style[^>]*>([\s\S]*?)<\/style>/gi);
+                for (const match of styleMatches) {
+                    mergedHTML += `<style>${match[1]}</style>\n`;
+                }
+                // Extract and inline <script> tags
+                const scriptMatches = fileContent.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/gi);
+                for (const match of scriptMatches) {
+                    if (match[1]) {
+                        mergedHTML += `<script>${match[1]}</script>\n`;
+                    }
+                }
+            }
+            const minified = await minifyHTML(mergedHTML, workspaceConfig.build?.obfuscation?.html);
+            result += minified.trim();
+        }
+        else if (['css', 'style', 'styles'].some((k) => key === k)) {
+            result += watermark.css + '\n';
+            if (verbose)
+                console.log(`  - Processing CSS...`);
+            const files = findAndRead(entryDir, list);
+            let mergedCSS = '';
+            for await (const content of files) {
+                const plugin = [
+                    autoprefixer({
+                        overrideBrowserslist: ['Chrome 127'],
+                        ...workspaceConfig.build?.obfuscation?.css?.autoprefixer,
+                    }),
+                    cssnano(workspaceConfig.build?.obfuscation?.css?.cssnano),
+                ];
+                if (workspaceConfig.build?.obfuscation?.css?.removeNesting) {
+                    plugin.unshift(nested());
+                }
+                const processed = await postcss(plugin).process(content, { from: undefined });
+                mergedCSS += processed.css + '\n';
+            }
+            result += mergedCSS.trim();
+        }
+        else if (['script', 'js', 'javascript'].some((k) => key === k)) {
+            result += watermark.script + '\n';
+            if (verbose)
+                console.log(`  - Processing JavaScript...`);
+            const files = findAndRead(entryDir, list);
+            let mergedJS = '';
+            for await (const content of files) {
+                const obfuscated = JavaScriptObfuscator.obfuscate(content, workspaceConfig.build?.obfuscation?.javascript);
+                mergedJS += obfuscated.getObfuscatedCode() + '\n';
+            }
+            result += mergedJS.trim();
+        }
+        else if (['fields', 'FIELDS', 'fielddata', 'fieldData'].some((k) => key === k)) {
+            if (verbose)
+                console.log(`  - Processing Json...`);
+            const files = findAndRead(entryDir, list);
+            let mergedFields = {};
+            for await (const content of files) {
+                try {
+                    const noComments = parse(content);
+                    const parsed = JSON.parse(JSON.stringify(noComments));
+                    mergedFields = {
+                        ...mergedFields,
+                        ...parsed,
+                    };
+                }
+                catch (error) {
+                    console.warn(`   ⚠️  Failed to parse fields JSON: ${error}`);
+                    throw error;
+                }
+            }
+            result += JSON.stringify(mergedFields, null, 2);
+        }
+        else {
+            if (verbose)
+                console.log(`  - Unknown build key: ${key}, the available keys are html, css, script and fields.`);
+            result += '';
+        }
+        return [key, result];
+    })));
+    for await (const [filename, key] of Object.entries(resultMapping)) {
+        const content = results[key];
+        if (content) {
+            const outPath = join(outDir, filename);
+            writeFileSync(outPath, content, 'utf-8');
+            if (verbose)
+                console.log(`   ✓ Written: ${outPath}`);
+        }
+    }
+    // widgetIO zip
+    try {
+        const zip = new JSZip();
+        for await (const [filename, key] of Object.entries(compactedMapping)) {
+            const content = results[key];
+            if (content) {
+                zip.file(filename, content);
+                if (verbose)
+                    console.log(`   ✓ Added to ZIP: ${filename}`);
+            }
+        }
+        zip.file('widget.ini', `[HTML]\npath = "html.txt"\n\n[CSS]\npath = "css.txt"\n\n[JS]\npath = "js.txt"\n\n[FIELDS]\npath = "fields.txt"\n\n[DATA]\npath = "data.txt"`);
+        // check if data.txt exists in results, otherwise create empty
+        const dataContent = results['data'] || '{}';
+        zip.file('data.txt', dataContent);
+        const result = await zip
+            .generateInternalStream({ type: 'base64' })
+            .accumulate()
+            .then((data) => data);
+        const zipPath = join(compactedDir + '/' + widget.config.version || '0.0.0', `${widget.config.name}.zip`);
+        mkdirSync(compactedDir + '/' + widget.config.version, { recursive: true });
+        writeFileSync(zipPath, result, 'base64');
+    }
+    catch (error) {
+        console.error(`❌ Failed to create widgetIO ZIP for widget ${widget.config.name}:`, error);
+        throw error;
+    }
+}
+export async function bumpVersion(widgetPath, bumpType = 'patch') {
+    try {
+        const configPath = join(widgetPath, '.tixyel');
+        const content = await readFilePromise(configPath, 'utf-8');
+        const config = parse(content);
+        if (!config.version) {
+            config.version = '0.0.0';
+        }
+        const [major, minor, patch] = config.version.split('.').map(Number);
+        let newVersion;
+        switch (bumpType) {
+            case 'major': {
+                newVersion = `${major + 1}.0.0`;
+                break;
+            }
+            case 'minor': {
+                newVersion = `${major}.${minor + 1}.0`;
+                break;
+            }
+            case 'patch': {
+                newVersion = `${major}.${minor}.${patch + 1}`;
+                break;
+            }
+        }
+        config.version = newVersion;
+        const formattedContent = JSON.stringify(config, null, 2);
+        await writeFile(configPath, formattedContent, 'utf-8');
+        return newVersion;
+    }
+    catch (error) {
+        console.error(`Failed to bump version in ${widgetPath}:`, error);
+        return null;
+    }
+}

package/dist/workspace.d.ts

@@ -0,0 +1,111 @@
+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';
+export type ScaffoldItem = ScaffoldFile | ScaffoldFolder;
+export interface ScaffoldFile {
+    name: string;
+    type: 'file';
+    content: string;
+}
+export interface ScaffoldFolder {
+    name: string;
+    type: 'folder';
+    content?: ScaffoldItem[];
+}
+export interface WorkspaceConfig<Find extends BuildFindMap = BuildFindMap> {
+    /**
+     * Search options for locating widget files
+     */
+    search?: {
+        /**
+         * Maximum directory depth to search
+         */
+        maxDepth?: number;
+        /**
+         * Folders and files to ignore during search
+         */
+        ignore?: string[];
+    };
+    /**
+     * Metadata applied to all widgets in the workspace
+     */
+    metadata?: {
+        name?: string;
+        author?: string;
+        clientId?: string;
+        description?: string;
+        tags?: string[];
+    };
+    dirs?: {
+        entry?: string;
+        output?: string;
+        compacted?: string;
+    };
+    /**
+     * Scaffold structure to create when generating a new widget
+     */
+    scaffold?: ScaffoldItem[];
+    /**
+     * Build configuration
+     */
+    build?: {
+        /**
+         * Run builds in parallel
+         */
+        parallel?: boolean;
+        /**
+         * Verbose output during build
+         */
+        verbose?: boolean;
+        /**
+         * File patterns to locate widget files
+         */
+        find?: Find;
+        /**
+         * Mapping of output files to find keys
+         */
+        result?: BuildResultMap<Find>;
+        /**
+         * Mapping of widgetIO output files to find keys
+         */
+        widgetIO?: BuildResultMap<Find>;
+        /**
+         * Obfuscation and minification settings
+         */
+        obfuscation?: {
+            /**
+             * JavaScript obfuscation options
+             */
+            javascript?: ObfuscatorOptions;
+            /**
+             * CSS minification options
+             */
+            css?: {
+                /**
+                 * Remove nesting rules
+                 */
+                removeNesting?: boolean;
+                /**
+                 * Autoprefixer options
+                 */
+                autoprefixer?: autoprefixer.Options;
+                /**
+                 * cssnano options
+                 */
+                cssnano?: cssnanoPlugin.Options;
+            };
+            /**
+             * HTML minification options
+             */
+            html?: HtmlMinifierOptions;
+        };
+    };
+}
+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 findWorkspaceRoot(startPath?: string): Promise<string | null>;
+export declare function validateWorkspace(): Promise<string>;
+export declare function loadWorkspace(path: string): Promise<WorkspaceConfig<BuildFindMap>>;
+export {};