@fluffjs/cli 0.0.8 → 0.1.1

package/ControlFlowParser.d.ts

@@ -1,55 +0,0 @@
-export interface IfBlock {
-    type: 'if';
-    condition: string;
-    ifContent: string;
-    elseContent: string;
-    start: number;
-    end: number;
-}
-export interface ForBlock {
-    type: 'for';
-    iterator: string;
-    iterable: string;
-    trackBy?: string;
-    content: string;
-    start: number;
-    end: number;
-}
-export interface SwitchCase {
-    value: string | null;
-    content: string;
-    fallthrough: boolean;
-}
-export interface SwitchBlock {
-    type: 'switch';
-    expression: string;
-    cases: SwitchCase[];
-    start: number;
-    end: number;
-}
-export type ControlFlowBlock = IfBlock | ForBlock | SwitchBlock;
-export declare class ControlFlowParser {
-    parseAll(input: string): {
-        result: string;
-        blocks: ControlFlowBlock[];
-    };
-    private findMatchingDelimiter;
-    private findMatchingBrace;
-    private extractParenContent;
-    private parseForExpression;
-    private parseBlockStructure;
-    parseSwitchBlocks(input: string): {
-        result: string;
-        blocks: SwitchBlock[];
-    };
-    private parseSwitchCases;
-    parseForBlocks(input: string): {
-        result: string;
-        blocks: ForBlock[];
-    };
-    parseIfBlocks(input: string): {
-        result: string;
-        blocks: IfBlock[];
-    };
-}
-//# sourceMappingURL=ControlFlowParser.d.ts.map

package/ControlFlowParser.js

@@ -1,279 +0,0 @@
-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/types.d.ts

@@ -1,46 +0,0 @@
-export interface ComponentInfo {
-    className: string;
-    selector: string;
-    templatePath: string;
-    stylePath?: string;
-    filePath: string;
-}
-export interface TemplateBinding {
-    id: string;
-    type: 'text' | 'property' | 'event' | 'class' | 'style';
-    expression: string;
-    target?: string;
-    eventName?: string;
-    className?: string;
-    styleProp?: string;
-}
-export interface SwitchCase {
-    value: string | null;
-    content: string;
-    fallthrough: boolean;
-}
-export interface ControlFlow {
-    id: string;
-    type: 'if' | 'for' | 'switch';
-    condition?: string;
-    ifContent?: string;
-    elseContent?: string;
-    iterator?: string;
-    iterable?: string;
-    trackBy?: string;
-    content?: string;
-    expression?: string;
-    cases?: SwitchCase[];
-}
-export interface ParsedTemplate {
-    html: string;
-    bindings: TemplateBinding[];
-    controlFlows: ControlFlow[];
-    templateRefs: string[];
-}
-export interface CompilerOptions {
-    srcDir: string;
-    distDir: string;
-    componentSelectors: Set<string>;
-}
-//# sourceMappingURL=types.d.ts.map