@tixyel/cli 2.7.0 → 3.0.0

package/dist/widget.js

@@ -1,551 +0,0 @@
-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 { 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';
-import inquirer from 'inquirer';
-import postcss from 'postcss';
-import cssnano from 'cssnano';
-import JSZip from 'jszip';
-import { transformSync } from 'esbuild';
-import { watermark } from './utils/watermark.js';
-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 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') {
-                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') {
-                const content = await serializeScaffoldContent(item.content);
-                await writeFile(fullPath, 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'],
-        typescript: ['script.ts'],
-        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[pattern] = content;
-            }
-        }
-        return contents;
-    };
-    const usedWatermarks = new Set();
-    const processedFile = new Set();
-    /**
-     * Build results processing
-     * Find all files based on patterns and process them according to their type
-     * (html, css, script, fields)
-     * Group results based on resultMapping and compactedMapping
-     * Compact/minify where applicable
-     */
-    const results = Object.fromEntries(await Promise.all(Object.entries(findPatterns).map(async ([key, patterns]) => {
-        let result = '';
-        let list = normalizeList(patterns.filter((p) => !processedFile.has(p)));
-        if (!list.length)
-            return [key, ''];
-        const check = (keys, formats) => {
-            !Array.isArray(keys) && (keys = [keys]);
-            !Array.isArray(formats) && (formats = [formats]);
-            return (
-            // check keys
-            keys.some((k) => key.toLowerCase() === k.toLowerCase()) ||
-                // check formats
-                list.some((p) => formats.some((f) => p.toLowerCase().endsWith(f.toLowerCase()))));
-        };
-        const processed = new Set();
-        // Process HTML
-        if (check('html', '.html')) {
-            if (!usedWatermarks.has('html'))
-                result += watermark.html(widget) + '\n';
-            usedWatermarks.add('html');
-            const fileList = list.filter((e) => e.endsWith('.html') && !processedFile.has(e));
-            if (verbose)
-                console.log(`  - Processing HTML for ${widget.config.name} [${key}, ${fileList.join(', ')}]...`);
-            const files = findAndRead(entryDir, fileList);
-            let mergedHTML = '';
-            for await (const [pattern, fileContent] of Object.entries(files)) {
-                // Extract body content
-                const bodyMatch = fileContent.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
-                if (bodyMatch && bodyMatch[1]) {
-                    mergedHTML += bodyMatch[1].trim() + '\n';
-                    processedFile.add(pattern);
-                }
-            }
-            const minified = await minifyHTML(mergedHTML, workspaceConfig.build?.obfuscation?.html);
-            result += minified.trim();
-            processed.add('html');
-        }
-        if (check(['css', 'style', 'styles'], '.css')) {
-            if (!usedWatermarks.has('css'))
-                result += watermark.css(widget) + '\n';
-            usedWatermarks.add('css');
-            const fileList = list.filter((e) => e.endsWith('.css') && !processedFile.has(e));
-            if (verbose)
-                console.log(`  - Processing CSS for ${widget.config.name} [${key}, ${fileList.join(', ')}]...`);
-            const files = findAndRead(entryDir, fileList);
-            let mergedCSS = '';
-            for await (const [pattern, content] of Object.entries(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';
-                processedFile.add(pattern);
-            }
-            if (processed.has('html')) {
-                result = result += `<style>${mergedCSS.trim()}</style>`;
-            }
-            else
-                result += mergedCSS.trim();
-            processed.add('css');
-        }
-        if (check(['typescript', 'ts'], '.ts')) {
-            if (!usedWatermarks.has('script'))
-                result += watermark.script(widget) + '\n';
-            usedWatermarks.add('script');
-            const fileList = list.filter((e) => e.endsWith('.ts') && !processedFile.has(e));
-            if (verbose)
-                console.log(`  - Processing TypeScript for ${widget.config.name} [${key}, ${fileList.join(', ')}]...`);
-            const files = findAndRead(entryDir, fileList);
-            let mergedTS = '';
-            for await (const [pattern, content] of Object.entries(files)) {
-                try {
-                    const transpiled = transformSync(content, {
-                        loader: 'ts',
-                        target: 'es2020',
-                        format: 'cjs',
-                    });
-                    mergedTS += transpiled.code + '\n';
-                }
-                catch (error) {
-                    console.warn(`   ⚠️  Failed to compile TypeScript: ${error}`);
-                    throw error;
-                }
-                finally {
-                    processedFile.add(pattern);
-                }
-            }
-            // Obfuscate the compiled JavaScript
-            const obfuscated = JavaScriptObfuscator.obfuscate(mergedTS.trim(), workspaceConfig.build?.obfuscation?.javascript);
-            if (processed.has('html')) {
-                result = result += `<script>${obfuscated.getObfuscatedCode()}</script>\n`;
-            }
-            else
-                result += obfuscated.getObfuscatedCode() + '\n';
-            processed.add('typescript');
-        }
-        if (check(['script', 'js', 'javascript'], '.js')) {
-            if (!usedWatermarks.has('script'))
-                result += watermark.script(widget) + '\n';
-            usedWatermarks.add('script');
-            const fileList = list.filter((e) => e.endsWith('.js') && !processedFile.has(e));
-            if (verbose)
-                console.log(`  - Processing JavaScript for ${widget.config.name} [${key}, ${fileList.join(', ')}]...`);
-            const files = findAndRead(entryDir, fileList);
-            let mergedJS = '';
-            for await (const [pattern, content] of Object.entries(files)) {
-                const obfuscated = JavaScriptObfuscator.obfuscate(content, workspaceConfig.build?.obfuscation?.javascript);
-                mergedJS += obfuscated.getObfuscatedCode() + '\n';
-                processedFile.add(pattern);
-            }
-            if (processed.has('html')) {
-                result = result += `<script>${mergedJS.trim()}</script>`;
-            }
-            else
-                result += mergedJS.trim();
-            processed.add('script');
-        }
-        if (check(['fields', 'fielddata', 'fieldData', 'cf', 'customfields'], '.json')) {
-            const fileList = list.filter((e) => e.endsWith('.json') && !processedFile.has(e));
-            if (verbose)
-                console.log(`  - Processing JSON for ${widget.config.name} [${key}, ${fileList.join(', ')}]...`);
-            const files = findAndRead(entryDir, fileList);
-            let mergedFields = {};
-            for await (const [pattern, content] of Object.entries(files)) {
-                try {
-                    const noComments = parse(content);
-                    const parsed = JSON.parse(JSON.stringify(noComments));
-                    Object.assign(mergedFields, parsed);
-                }
-                catch (error) {
-                    console.warn(`   ⚠️  Failed to parse fields JSON: ${error}`);
-                    throw error;
-                }
-            }
-            if (!processed.size)
-                result += JSON.stringify(mergedFields, null, 2);
-            processed.add('fields');
-        }
-        if (!result.length) {
-            if (verbose)
-                console.log(`  - Unknown build key: ${key}, the available keys are html, css, script and fields.`);
-            result += '';
-        }
-        return [key, result];
-    })));
-    if (verbose) {
-        console.log(`   - Build results:`, Object.keys(results)
-            .map((k) => `${k}: ${results[k].length} bytes`)
-            .join(', '));
-    }
-    for await (const [filename, key] of Object.entries(resultMapping)) {
-        let content = '';
-        if (typeof key === 'string')
-            content = results[key];
-        else if (Array.isArray(key)) {
-            for await (const k of key) {
-                const part = results[k];
-                if (part) {
-                    content += '\n' + part;
-                    if (verbose)
-                        console.log(`   ✓ Merged part for: ${k}`);
-                }
-            }
-        }
-        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)) {
-            let content = '';
-            if (typeof key === 'string')
-                content = results[key];
-            else if (Array.isArray(key)) {
-                for await (const k of key) {
-                    const part = results[k];
-                    if (part) {
-                        content += '\n' + part;
-                        if (verbose)
-                            console.log(`   ✓ Merged part for ZIP: ${k}`);
-                    }
-                }
-            }
-            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/widget.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/widget.test.js

@@ -1,14 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { transformSync } from 'esbuild';
-describe('Should parse typescript into javascript', () => {
-    const tsContent = `function wait(ms: number) { return new Promise((resolve) => setTimeout(resolve, ms));}`;
-    const transpiled = transformSync(tsContent, {
-        loader: 'ts',
-        target: 'es2020',
-        format: 'cjs',
-    });
-    it('should transpile TypeScript to JavaScript', () => {
-        expect(transpiled.code).toContain('function wait(ms) {');
-        expect(transpiled.code).toContain('return new Promise((resolve) => setTimeout(resolve, ms));');
-    });
-});

package/dist/workspace.d.ts

@@ -1,113 +0,0 @@
-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 | JSX.Element;
-}
-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 | (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>>;
-export {};