@fluffjs/cli 0.0.1

package/ControlFlowParser.js

@@ -0,0 +1,279 @@
+import { parse } from '@babel/parser';
+import * as t from '@babel/types';
+const OPENING_BRACE_PATTERN = /^\s*\{/;
+const OPENING_BRACE_WITH_PAREN_PATTERN = /^\)?\s*\{/;
+const FALLTHROUGH_PATTERN = /@fallthrough\s*$/;
+export class ControlFlowParser {
+    parseAll(input) {
+        let result = input;
+        const allBlocks = [];
+        const switchResult = this.parseSwitchBlocks(result);
+        ({ result } = switchResult);
+        allBlocks.push(...switchResult.blocks);
+        const forResult = this.parseForBlocks(result);
+        ({ result } = forResult);
+        allBlocks.push(...forResult.blocks);
+        const ifResult = this.parseIfBlocks(result);
+        ({ result } = ifResult);
+        allBlocks.push(...ifResult.blocks);
+        return { result, blocks: allBlocks };
+    }
+    findMatchingDelimiter(str, openIdx, openChar, closeChar) {
+        let depth = 1;
+        let inString = false;
+        let i = openIdx + 1;
+        while (i < str.length && depth > 0) {
+            const char = str[i];
+            const prevChar = str[i - 1];
+            if (prevChar === '\\' && inString) {
+                i++;
+                continue;
+            }
+            if (!inString) {
+                if (char === '"' || char === '\'' || char === '`') {
+                    inString = char;
+                }
+                else if (char === openChar) {
+                    depth++;
+                }
+                else if (char === closeChar) {
+                    depth--;
+                }
+            }
+            else {
+                if (char === inString) {
+                    inString = false;
+                }
+                else if (inString === '`' && char === '$' && str[i + 1] === '{') {
+                    i += 2;
+                    let templateDepth = 1;
+                    while (i < str.length && templateDepth > 0) {
+                        const tc = str[i];
+                        if (tc === '{')
+                            templateDepth++;
+                        else if (tc === '}')
+                            templateDepth--;
+                        else if (tc === '`') {
+                            i++;
+                            while (i < str.length && str[i] !== '`') {
+                                if (str[i] === '\\')
+                                    i++;
+                                i++;
+                            }
+                        }
+                        i++;
+                    }
+                    continue;
+                }
+            }
+            i++;
+        }
+        return depth === 0 ? i - 1 : -1;
+    }
+    findMatchingBrace(str, openIdx) {
+        return this.findMatchingDelimiter(str, openIdx, '{', '}');
+    }
+    extractParenContent(str, startIdx) {
+        if (str[startIdx] !== '(')
+            return null;
+        const endIdx = this.findMatchingDelimiter(str, startIdx, '(', ')');
+        if (endIdx === -1)
+            return null;
+        return {
+            content: str.slice(startIdx + 1, endIdx), endIdx
+        };
+    }
+    parseForExpression(expr) {
+        let mainExpr = expr;
+        let trackBy = undefined;
+        const trackIndex = expr.indexOf('; track ');
+        if (trackIndex !== -1) {
+            mainExpr = expr.slice(0, trackIndex);
+            trackBy = expr.slice(trackIndex + 8)
+                .trim();
+        }
+        try {
+            const wrappedCode = `for (const ${mainExpr}) {}`;
+            const ast = parse(wrappedCode, { sourceType: 'module' });
+            const [stmt] = ast.program.body;
+            if (!t.isForOfStatement(stmt))
+                return null;
+            const { left } = stmt;
+            let iterator = '';
+            if (t.isVariableDeclaration(left) && left.declarations.length === 1) {
+                const [decl] = left.declarations;
+                if (t.isIdentifier(decl.id)) {
+                    iterator = decl.id.name;
+                }
+                else {
+                    iterator = mainExpr.slice(0, mainExpr.indexOf(' of '))
+                        .trim();
+                }
+            }
+            else {
+                return null;
+            }
+            const ofIndex = mainExpr.indexOf(' of ');
+            if (ofIndex === -1)
+                return null;
+            const iterable = mainExpr.slice(ofIndex + 4)
+                .trim();
+            return { iterator, iterable, trackBy };
+        }
+        catch {
+            const ofIndex = mainExpr.indexOf(' of ');
+            if (ofIndex === -1)
+                return null;
+            const fallbackIterator = mainExpr.slice(0, ofIndex)
+                .trim();
+            const iterable = mainExpr.slice(ofIndex + 4)
+                .trim();
+            return { iterator: fallbackIterator, iterable, trackBy };
+        }
+    }
+    parseBlockStructure(input, match) {
+        const parenStart = match.index + match[0].length - 1;
+        const exprResult = this.extractParenContent(input, parenStart);
+        if (!exprResult)
+            return null;
+        const afterExpr = input.slice(exprResult.endIdx + 1);
+        const braceMatch = OPENING_BRACE_PATTERN.exec(afterExpr);
+        if (!braceMatch)
+            return null;
+        const braceStart = exprResult.endIdx + 1 + braceMatch[0].length - 1;
+        const braceEnd = this.findMatchingBrace(input, braceStart);
+        if (braceEnd === -1)
+            return null;
+        return {
+            expr: exprResult.content.trim(),
+            content: input.slice(braceStart + 1, braceEnd)
+                .trim(),
+            braceEnd
+        };
+    }
+    parseSwitchBlocks(input) {
+        const blocks = [];
+        let result = input;
+        const switchRegex = /@switch\s*\(/g;
+        let match = null;
+        while ((match = switchRegex.exec(result)) !== null) {
+            const startIdx = match.index;
+            const parsed = this.parseBlockStructure(result, match);
+            if (!parsed)
+                continue;
+            const cases = this.parseSwitchCases(parsed.content);
+            blocks.push({
+                type: 'switch', expression: parsed.expr, cases, start: startIdx, end: parsed.braceEnd
+            });
+            const placeholder = `__SWITCH_BLOCK_${blocks.length - 1}`;
+            result = result.slice(0, startIdx) + placeholder + result.slice(parsed.braceEnd + 1);
+            switchRegex.lastIndex = startIdx + placeholder.length;
+        }
+        return { result, blocks };
+    }
+    parseSwitchCases(switchBody) {
+        const cases = [];
+        const caseRegex = /@(case|default)\s*\(?/g;
+        let match = null;
+        while ((match = caseRegex.exec(switchBody)) !== null) {
+            const [, caseType] = match;
+            let value = null;
+            let contentStart = 0;
+            if (caseType === 'case') {
+                const parenIdx = switchBody.indexOf('(', match.index);
+                if (parenIdx === -1)
+                    continue;
+                const valueResult = this.extractParenContent(switchBody, parenIdx);
+                if (!valueResult)
+                    continue;
+                value = valueResult.content.trim();
+                const afterValue = switchBody.slice(valueResult.endIdx + 1);
+                const braceMatch = OPENING_BRACE_PATTERN.exec(afterValue);
+                if (!braceMatch)
+                    continue;
+                contentStart = valueResult.endIdx + 1 + braceMatch[0].length;
+            }
+            else {
+                const afterDefault = switchBody.slice(match.index + match[0].length);
+                const braceMatch = OPENING_BRACE_WITH_PAREN_PATTERN.exec(afterDefault);
+                if (!braceMatch)
+                    continue;
+                contentStart = match.index + match[0].length + braceMatch[0].length;
+            }
+            const contentEnd = this.findMatchingBrace(switchBody, contentStart - 1);
+            if (contentEnd === -1)
+                continue;
+            let content = switchBody.slice(contentStart, contentEnd);
+            const fallthrough = FALLTHROUGH_PATTERN.test(content.trim());
+            if (fallthrough) {
+                content = content.replace(FALLTHROUGH_PATTERN, '')
+                    .trim();
+            }
+            cases.push({
+                value, content: content.trim(), fallthrough
+            });
+            caseRegex.lastIndex = contentEnd + 1;
+        }
+        return cases;
+    }
+    parseForBlocks(input) {
+        const blocks = [];
+        let result = input;
+        const forRegex = /@for\s*\(/g;
+        let match = null;
+        while ((match = forRegex.exec(result)) !== null) {
+            const startIdx = match.index;
+            const parsed = this.parseBlockStructure(result, match);
+            if (!parsed)
+                continue;
+            const forParts = this.parseForExpression(parsed.expr);
+            if (!forParts)
+                continue;
+            const { iterator, iterable, trackBy } = forParts;
+            blocks.push({
+                type: 'for', iterator, iterable, trackBy, content: parsed.content, start: startIdx, end: parsed.braceEnd
+            });
+            const placeholder = `__FOR_BLOCK_${blocks.length - 1}__`;
+            result = result.slice(0, startIdx) + placeholder + result.slice(parsed.braceEnd + 1);
+            forRegex.lastIndex = startIdx + placeholder.length;
+        }
+        return { result, blocks };
+    }
+    parseIfBlocks(input) {
+        const blocks = [];
+        let result = input;
+        const ifRegex = /@if\s*\(/g;
+        let match = null;
+        while ((match = ifRegex.exec(result)) !== null) {
+            const startIdx = match.index;
+            const parsed = this.parseBlockStructure(result, match);
+            if (!parsed)
+                continue;
+            let elseContent = '';
+            let totalEnd = parsed.braceEnd;
+            const afterIf = result.slice(parsed.braceEnd + 1);
+            const elseMatch = /^\s*@else\s*\{/.exec(afterIf);
+            if (elseMatch) {
+                const elseBraceStart = parsed.braceEnd + 1 + elseMatch[0].length - 1;
+                const elseBraceEnd = this.findMatchingBrace(result, elseBraceStart);
+                if (elseBraceEnd !== -1) {
+                    elseContent = result.slice(elseBraceStart + 1, elseBraceEnd)
+                        .trim();
+                    totalEnd = elseBraceEnd;
+                }
+            }
+            blocks.push({
+                type: 'if',
+                condition: parsed.expr,
+                ifContent: parsed.content,
+                elseContent,
+                start: startIdx,
+                end: totalEnd
+            });
+            const placeholder = `__IF_BLOCK_${blocks.length - 1}__`;
+            result = result.slice(0, startIdx) + placeholder + result.slice(totalEnd + 1);
+            ifRegex.lastIndex = startIdx + placeholder.length;
+        }
+        return { result, blocks };
+    }
+}

package/ExpressionTransformer.d.ts

@@ -0,0 +1,30 @@
+export interface TransformOptions {
+    addThisPrefix?: boolean;
+    nullSafe?: boolean;
+    iteratorName?: string;
+    iteratorReplacement?: string;
+    localVars?: string[];
+}
+export declare function transformExpression(expr: string, options?: TransformOptions): string;
+export declare function addThisPrefix(expr: string): string;
+export declare function addThisPrefixSafe(expr: string): string;
+export declare function transformForExpression(expr: string, iteratorName: string, iteratorReplacement: string): string;
+export declare function transformForExpressionKeepIterator(expr: string, iteratorName: string): string;
+export declare function parsePipedExpression(expr: string): {
+    expression: string;
+    pipes: {
+        name: string;
+        args: string[];
+    }[];
+};
+export declare function transformInterpolation(expr: string, iteratorVar?: string): string;
+export declare function extractRootIdentifier(expr: string): string | null;
+export declare function parseInterpolations(text: string): {
+    start: number;
+    end: number;
+    expr: string;
+}[];
+export declare function transformPipedExpression(expr: string, addThisPrefixToExpr?: boolean): string;
+export declare function renameVariable(expr: string, oldName: string, newName: string): string;
+export declare function expressionUsesVariable(expr: string, varName: string): boolean;
+//# sourceMappingURL=ExpressionTransformer.d.ts.map

package/ExpressionTransformer.js

@@ -0,0 +1,276 @@
+import _generate from '@babel/generator';
+import { parse } from '@babel/parser';
+import _traverse from '@babel/traverse';
+import * as t from '@babel/types';
+const traverse = _traverse.default ?? _traverse;
+const generate = _generate.default ?? _generate;
+export function transformExpression(expr, options = {}) {
+    const { addThisPrefix: shouldAddThisPrefix = true, nullSafe = false, iteratorName, iteratorReplacement, localVars = [] } = options;
+    try {
+        const ast = parse(`(${expr})`, {
+            sourceType: 'module', plugins: ['typescript']
+        });
+        traverse(ast, {
+            Identifier(path) {
+                const { name } = path.node;
+                if (['true', 'false', 'null', 'undefined', 'this'].includes(name)) {
+                    return;
+                }
+                if (localVars.includes(name)) {
+                    return;
+                }
+                if (t.isMemberExpression(path.parent) && path.parent.property === path.node && !path.parent.computed) {
+                    return;
+                }
+                if (t.isOptionalMemberExpression(path.parent) && path.parent.property === path.node) {
+                    return;
+                }
+                if (iteratorName && name === iteratorName && iteratorReplacement) {
+                    const replacementAst = parse(`(${iteratorReplacement})`, { sourceType: 'module' });
+                    const [firstStmt] = replacementAst.program.body;
+                    if (!t.isExpressionStatement(firstStmt))
+                        return;
+                    const replacementExpr = firstStmt.expression;
+                    path.replaceWith(replacementExpr);
+                    return;
+                }
+                if (shouldAddThisPrefix) {
+                    path.replaceWith(t.memberExpression(t.thisExpression(), t.identifier(name)));
+                }
+            }
+        });
+        if (nullSafe) {
+            traverse(ast, {
+                MemberExpression: {
+                    exit(path) {
+                        const obj = path.node.object;
+                        const isThisMember = t.isMemberExpression(obj) && t.isThisExpression(obj.object);
+                        const isOptionalChain = t.isOptionalMemberExpression(obj);
+                        const isDeepChain = t.isMemberExpression(obj);
+                        if (!path.node.optional && (isThisMember || isOptionalChain || isDeepChain)) {
+                            const prop = path.node.property;
+                            if (t.isExpression(prop)) {
+                                const newNode = t.optionalMemberExpression(path.node.object, prop, path.node.computed, true);
+                                path.replaceWith(newNode);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        const output = generate(ast, { compact: true });
+        let { code } = output;
+        if (code.startsWith('(') && code.endsWith(');')) {
+            code = code.slice(1, -2);
+        }
+        else if (code.startsWith('(') && code.endsWith(')')) {
+            code = code.slice(1, -1);
+        }
+        code = code.replace(/;+$/, '');
+        return code;
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to parse expression "${expr}": ${message}`);
+    }
+}
+export function addThisPrefix(expr) {
+    return transformExpression(expr, { addThisPrefix: true, nullSafe: false });
+}
+export function addThisPrefixSafe(expr) {
+    return transformExpression(expr, { addThisPrefix: true, nullSafe: true });
+}
+export function transformForExpression(expr, iteratorName, iteratorReplacement) {
+    return transformExpression(expr, {
+        addThisPrefix: true,
+        nullSafe: false,
+        iteratorName,
+        iteratorReplacement,
+        localVars: ['__items', '__idx', '__item']
+    });
+}
+export function transformForExpressionKeepIterator(expr, iteratorName) {
+    return transformExpression(expr, {
+        addThisPrefix: true, nullSafe: false, localVars: [iteratorName, '__items', '__idx', '__item', '__currentItems']
+    });
+}
+export function parsePipedExpression(expr) {
+    let remaining = expr.trim();
+    const pipes = [];
+    while (true) {
+        let pipeIdx = -1;
+        for (let i = remaining.length - 1; i >= 0; i--) {
+            if (remaining[i] === '|') {
+                if (remaining[i - 1] === '|' || remaining[i + 1] === '|')
+                    continue;
+                const left = remaining.slice(0, i)
+                    .trim();
+                if (!left)
+                    continue;
+                try {
+                    parse(left, { sourceType: 'module' });
+                    pipeIdx = i;
+                    break;
+                }
+                catch {
+                }
+            }
+        }
+        if (pipeIdx === -1)
+            break;
+        const pipeExpr = remaining.slice(pipeIdx + 1)
+            .trim();
+        const colonParts = pipeExpr.split(':');
+        const pipeName = colonParts[0].trim();
+        const args = colonParts.slice(1)
+            .map(s => s.trim());
+        pipes.unshift({ name: pipeName, args });
+        remaining = remaining.slice(0, pipeIdx)
+            .trim();
+    }
+    return { expression: remaining, pipes };
+}
+export function transformInterpolation(expr, iteratorVar) {
+    const localVars = iteratorVar ? [iteratorVar] : [];
+    const { expression: baseExpr, pipes } = parsePipedExpression(expr);
+    if (pipes.length > 0) {
+        let result = transformExpression(baseExpr, { addThisPrefix: true, nullSafe: true, localVars });
+        for (const pipe of pipes) {
+            const argsStr = pipe.args.length > 0 ? ', ' + pipe.args.join(', ') : '';
+            result = `this.__pipe('${pipe.name}', ${result}${argsStr})`;
+        }
+        return `${result} ?? ''`;
+    }
+    const transformed = transformExpression(expr, { addThisPrefix: true, nullSafe: true, localVars });
+    return `${transformed} ?? ''`;
+}
+export function extractRootIdentifier(expr) {
+    try {
+        const ast = parse(expr, { sourceType: 'module' });
+        const [stmt] = ast.program.body;
+        if (!t.isExpressionStatement(stmt))
+            return null;
+        let node = stmt.expression;
+        while (true) {
+            if (t.isIdentifier(node)) {
+                return node.name;
+            }
+            else if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
+                node = node.object;
+            }
+            else if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
+                node = node.callee;
+            }
+            else if (t.isBinaryExpression(node) || t.isLogicalExpression(node)) {
+                node = node.left;
+            }
+            else if (t.isUnaryExpression(node)) {
+                node = node.argument;
+            }
+            else if (t.isConditionalExpression(node)) {
+                node = node.test;
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to parse expression "${expr}": ${message}`);
+    }
+}
+export function parseInterpolations(text) {
+    const results = [];
+    let searchStart = 0;
+    while (searchStart < text.length) {
+        const openIdx = text.indexOf('{{', searchStart);
+        if (openIdx === -1)
+            break;
+        let foundValid = false;
+        for (let closeIdx = openIdx + 3; closeIdx <= text.length; closeIdx++) {
+            if (text[closeIdx - 2] !== '}' || text[closeIdx - 1] !== '}')
+                continue;
+            const candidate = text.slice(openIdx + 2, closeIdx - 2)
+                .trim();
+            if (!candidate)
+                continue;
+            const { expression: baseExpr } = parsePipedExpression(candidate);
+            try {
+                parse(baseExpr, { sourceType: 'module' });
+                results.push({
+                    start: openIdx, end: closeIdx, expr: candidate
+                });
+                searchStart = closeIdx;
+                foundValid = true;
+                break;
+            }
+            catch {
+            }
+        }
+        if (!foundValid) {
+            searchStart = openIdx + 2;
+        }
+    }
+    return results;
+}
+export function transformPipedExpression(expr, addThisPrefixToExpr = true) {
+    const { expression, pipes } = parsePipedExpression(expr);
+    if (pipes.length === 0) {
+        return expression;
+    }
+    let result = addThisPrefixToExpr ? transformExpression(expression, {
+        addThisPrefix: true,
+        nullSafe: true
+    }) : expression;
+    for (const pipe of pipes) {
+        const argsStr = pipe.args.length > 0 ? ', ' + pipe.args.join(', ') : '';
+        result = `this.__pipe('${pipe.name}', ${result}${argsStr})`;
+    }
+    return result;
+}
+export function renameVariable(expr, oldName, newName) {
+    try {
+        const ast = parse(expr, { sourceType: 'module' });
+        traverse(ast, {
+            Identifier(path) {
+                if (path.node.name === oldName) {
+                    if (t.isMemberExpression(path.parent) && path.parent.property === path.node && !path.parent.computed) {
+                        return;
+                    }
+                    path.node.name = newName;
+                }
+            }
+        });
+        let { code } = generate(ast, { compact: false });
+        if (code.endsWith(';'))
+            code = code.slice(0, -1);
+        return code;
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to parse expression "${expr}": ${message}`);
+    }
+}
+export function expressionUsesVariable(expr, varName) {
+    try {
+        const ast = parse(expr, { sourceType: 'module' });
+        let found = false;
+        traverse(ast, {
+            Identifier(path) {
+                if (path.node.name === varName) {
+                    if (t.isMemberExpression(path.parent) && path.parent.property === path.node && !path.parent.computed) {
+                        return;
+                    }
+                    found = true;
+                    path.stop();
+                }
+            }
+        });
+        return found;
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to parse expression "${expr}": ${message}`);
+    }
+}

package/Generator.d.ts

@@ -0,0 +1,21 @@
+interface GeneratorOptions {
+    appName: string;
+    outputDir: string;
+}
+export declare class Generator {
+    generate(options: GeneratorOptions): void;
+    private writeFile;
+    private toKebabCase;
+    private toPascalCase;
+    private toTitleCase;
+    private getPackageJson;
+    private getTsConfig;
+    private getFluffJson;
+    private getIndexHtml;
+    private getMainTs;
+    private getComponentTs;
+    private getComponentHtml;
+    private getComponentCss;
+}
+export {};
+//# sourceMappingURL=Generator.d.ts.map