@fluffjs/cli 0.0.1

package/babel-plugin-reactive.js

@@ -0,0 +1,411 @@
+import { types as t } from '@babel/core';
+export const reactivePropertiesMap = new Map();
+export default function reactivePlugin() {
+    return {
+        name: 'babel-plugin-reactive', visitor: {
+            Program: {
+                enter(path, state) {
+                    state.needsPropertyImport = false;
+                    state.reactiveProperties = new Set();
+                    state.watchMethods = [];
+                }, exit(path, state) {
+                    const filename = state.filename ?? 'unknown';
+                    if (state.reactiveProperties && state.reactiveProperties.size > 0) {
+                        reactivePropertiesMap.set(filename, state.reactiveProperties);
+                    }
+                    if (state.needsPropertyImport) {
+                        const hasPropertyImport = path.node.body.some(node => {
+                            if (t.isImportDeclaration(node)) {
+                                return node.specifiers.some(spec => t.isImportSpecifier(spec) && t.isIdentifier(spec.imported) && spec.imported.name === 'Property');
+                            }
+                            return false;
+                        });
+                        if (!hasPropertyImport) {
+                            const importDecl = t.importDeclaration([t.importSpecifier(t.identifier('Property'), t.identifier('Property'))], t.stringLiteral('@fluffjs/fluff'));
+                            path.node.body.unshift(importDecl);
+                        }
+                    }
+                }
+            },
+            ClassBody(path, state) {
+                const watchCalls = [];
+                const watchCallProps = [];
+                for (const memberPath of path.get('body')) {
+                    if (!memberPath.isClassProperty())
+                        continue;
+                    const init = memberPath.node.value;
+                    if (!init || !t.isCallExpression(init))
+                        continue;
+                    const { callee } = init;
+                    if (!t.isMemberExpression(callee))
+                        continue;
+                    if (!t.isThisExpression(callee.object))
+                        continue;
+                    if (!t.isIdentifier(callee.property) || callee.property.name !== '$watch')
+                        continue;
+                    const propName = t.isIdentifier(memberPath.node.key) ? memberPath.node.key.name : null;
+                    if (!propName)
+                        continue;
+                    const args = init.arguments;
+                    if (args.length < 2)
+                        continue;
+                    const [propsArg, callbackArg] = args;
+                    if (!t.isArrayExpression(propsArg))
+                        continue;
+                    const watchedProps = propsArg.elements
+                        .filter((el) => t.isStringLiteral(el))
+                        .map(el => el.value);
+                    watchCalls.push({ propName, watchedProps, callbackArg });
+                    watchCallProps.push(memberPath);
+                }
+                for (const p of watchCallProps) {
+                    p.remove();
+                }
+                const newMembers = [];
+                const propsToRemove = [];
+                const watchMethods = [];
+                const privateFields = [];
+                const getterHostBindingUpdates = [];
+                const propertyHostBindingInits = [];
+                const pipeMethods = [];
+                const hostListeners = [];
+                for (const memberPath of path.get('body')) {
+                    if (memberPath.isClassMethod()) {
+                        const methodNode = memberPath.node;
+                        const decorators = methodNode.decorators ?? [];
+                        const hostListenerIndex = decorators.findIndex(dec => {
+                            if (t.isCallExpression(dec.expression) && t.isIdentifier(dec.expression.callee)) {
+                                return dec.expression.callee.name === 'HostListener';
+                            }
+                            return false;
+                        });
+                        if (hostListenerIndex >= 0) {
+                            const hostListenerDecorator = decorators[hostListenerIndex];
+                            if (t.isCallExpression(hostListenerDecorator.expression)) {
+                                const args = hostListenerDecorator.expression.arguments;
+                                if (args.length > 0 && t.isStringLiteral(args[0])) {
+                                    const eventName = args[0].value;
+                                    if (t.isIdentifier(methodNode.key)) {
+                                        hostListeners.push({
+                                            methodName: methodNode.key.name, eventName
+                                        });
+                                    }
+                                }
+                            }
+                            decorators.splice(hostListenerIndex, 1);
+                        }
+                        const pipeDecoratorIndex = decorators.findIndex(dec => {
+                            if (t.isCallExpression(dec.expression) && t.isIdentifier(dec.expression.callee)) {
+                                return dec.expression.callee.name === 'Pipe';
+                            }
+                            return false;
+                        });
+                        if (pipeDecoratorIndex >= 0) {
+                            const pipeDecorator = decorators[pipeDecoratorIndex];
+                            if (t.isCallExpression(pipeDecorator.expression)) {
+                                const args = pipeDecorator.expression.arguments;
+                                if (args.length > 0 && t.isStringLiteral(args[0])) {
+                                    const pipeName = args[0].value;
+                                    if (t.isIdentifier(methodNode.key)) {
+                                        pipeMethods.push({
+                                            pipeName, methodName: methodNode.key.name
+                                        });
+                                    }
+                                }
+                            }
+                            decorators.splice(pipeDecoratorIndex, 1);
+                        }
+                        const watchDecoratorIndex = decorators.findIndex(dec => {
+                            if (t.isCallExpression(dec.expression) && t.isIdentifier(dec.expression.callee)) {
+                                return dec.expression.callee.name === 'Watch';
+                            }
+                            return false;
+                        });
+                        if (watchDecoratorIndex >= 0) {
+                            const watchDecorator = decorators[watchDecoratorIndex];
+                            if (t.isCallExpression(watchDecorator.expression)) {
+                                const args = watchDecorator.expression.arguments;
+                                const watchedProps = args
+                                    .filter((arg) => t.isStringLiteral(arg))
+                                    .map(arg => arg.value);
+                                if (t.isIdentifier(methodNode.key) && watchedProps.length > 0) {
+                                    watchMethods.push({
+                                        methodName: methodNode.key.name, watchedProps
+                                    });
+                                }
+                            }
+                            decorators.splice(watchDecoratorIndex, 1);
+                        }
+                        if (methodNode.kind === 'get') {
+                            const hostBindingIndex = decorators.findIndex(dec => {
+                                if (t.isCallExpression(dec.expression) && t.isIdentifier(dec.expression.callee)) {
+                                    return dec.expression.callee.name === 'HostBinding';
+                                }
+                                return false;
+                            });
+                            if (hostBindingIndex >= 0) {
+                                const hostBindingDecorator = decorators[hostBindingIndex];
+                                if (t.isCallExpression(hostBindingDecorator.expression)) {
+                                    const args = hostBindingDecorator.expression.arguments;
+                                    if (args.length > 0 && t.isStringLiteral(args[0]) && t.isIdentifier(methodNode.key)) {
+                                        const hostProperty = args[0].value;
+                                        const getterName = methodNode.key.name;
+                                        let updateStatement = t.emptyStatement();
+                                        if (hostProperty.startsWith('class.')) {
+                                            const className = hostProperty.slice(6);
+                                            updateStatement = t.ifStatement(t.identifier('__v'), t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('classList')), t.identifier('add')), [t.stringLiteral(className)])), t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('classList')), t.identifier('remove')), [t.stringLiteral(className)])));
+                                        }
+                                        else if (hostProperty.startsWith('attr.')) {
+                                            const attrName = hostProperty.slice(5);
+                                            updateStatement = t.ifStatement(t.binaryExpression('!=', t.identifier('__v'), t.nullLiteral()), t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('setAttribute')), [
+                                                t.stringLiteral(attrName),
+                                                t.callExpression(t.identifier('String'), [t.identifier('__v')])
+                                            ])), t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('removeAttribute')), [t.stringLiteral(attrName)])));
+                                        }
+                                        else if (hostProperty.startsWith('style.')) {
+                                            const styleProp = hostProperty.slice(6);
+                                            updateStatement = t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('style')), t.identifier(styleProp)), t.logicalExpression('||', t.identifier('__v'), t.stringLiteral(''))));
+                                        }
+                                        else {
+                                            updateStatement = t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier(hostProperty)), t.identifier('__v')));
+                                        }
+                                        const updateMethod = t.classMethod('method', t.identifier(`__updateHostBinding_${getterName}`), [], t.blockStatement([
+                                            t.variableDeclaration('const', [t.variableDeclarator(t.identifier('__v'), t.memberExpression(t.thisExpression(), t.identifier(getterName)))]),
+                                            updateStatement
+                                        ]));
+                                        newMembers.push(updateMethod);
+                                        getterHostBindingUpdates.push(`__updateHostBinding_${getterName}`);
+                                    }
+                                }
+                                decorators.splice(hostBindingIndex, 1);
+                            }
+                        }
+                        continue;
+                    }
+                    if (!memberPath.isClassProperty())
+                        continue;
+                    const propNode = memberPath.node;
+                    const decorators = propNode.decorators ?? [];
+                    const hostBindingDecoratorIndex = decorators.findIndex(dec => {
+                        if (t.isCallExpression(dec.expression) && t.isIdentifier(dec.expression.callee)) {
+                            return dec.expression.callee.name === 'HostBinding';
+                        }
+                        return false;
+                    });
+                    if (hostBindingDecoratorIndex >= 0) {
+                        const hostBindingDecorator = decorators[hostBindingDecoratorIndex];
+                        if (t.isCallExpression(hostBindingDecorator.expression)) {
+                            const args = hostBindingDecorator.expression.arguments;
+                            if (args.length > 0 && t.isStringLiteral(args[0]) && t.isIdentifier(propNode.key)) {
+                                const hostProperty = args[0].value;
+                                const propName = propNode.key.name;
+                                const privateName = `__hostBinding_${propName}`;
+                                const initialValue = propNode.value ?? t.identifier('undefined');
+                                const privateField = t.classProperty(t.identifier(privateName), initialValue);
+                                const getter = t.classMethod('get', t.identifier(propName), [], t.blockStatement([
+                                    t.returnStatement(t.memberExpression(t.thisExpression(), t.identifier(privateName)))
+                                ]));
+                                let updateStatement = t.emptyStatement();
+                                if (hostProperty.startsWith('class.')) {
+                                    const className = hostProperty.slice(6);
+                                    updateStatement = t.ifStatement(t.identifier('__v'), t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('classList')), t.identifier('add')), [t.stringLiteral(className)])), t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('classList')), t.identifier('remove')), [t.stringLiteral(className)])));
+                                }
+                                else if (hostProperty.startsWith('attr.')) {
+                                    const attrName = hostProperty.slice(5);
+                                    updateStatement = t.ifStatement(t.binaryExpression('!=', t.identifier('__v'), t.nullLiteral()), t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('setAttribute')), [
+                                        t.stringLiteral(attrName),
+                                        t.callExpression(t.identifier('String'), [t.identifier('__v')])
+                                    ])), t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('removeAttribute')), [t.stringLiteral(attrName)])));
+                                }
+                                else if (hostProperty.startsWith('style.')) {
+                                    const styleProp = hostProperty.slice(6);
+                                    updateStatement = t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('style')), t.identifier(styleProp)), t.logicalExpression('||', t.identifier('__v'), t.stringLiteral(''))));
+                                }
+                                else {
+                                    updateStatement = t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier(hostProperty)), t.identifier('__v')));
+                                }
+                                const setter = t.classMethod('set', t.identifier(propName), [t.identifier('__v')], t.blockStatement([
+                                    t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier(privateName)), t.identifier('__v'))),
+                                    updateStatement
+                                ]));
+                                newMembers.push(getter, setter);
+                                propsToRemove.push(memberPath);
+                                propertyHostBindingInits.push({ propName, privateName });
+                                path.unshiftContainer('body', privateField);
+                            }
+                        }
+                        continue;
+                    }
+                    const viewChildDecoratorIndex = decorators.findIndex(dec => {
+                        if (t.isCallExpression(dec.expression) && t.isIdentifier(dec.expression.callee)) {
+                            return dec.expression.callee.name === 'ViewChild';
+                        }
+                        return false;
+                    });
+                    if (viewChildDecoratorIndex >= 0) {
+                        const viewChildDecorator = decorators[viewChildDecoratorIndex];
+                        if (t.isCallExpression(viewChildDecorator.expression)) {
+                            const args = viewChildDecorator.expression.arguments;
+                            if (args.length > 0 && t.isStringLiteral(args[0]) && t.isIdentifier(propNode.key)) {
+                                const selector = args[0].value;
+                                const propName = propNode.key.name;
+                                const getter = t.classMethod('get', t.identifier(propName), [], t.blockStatement([
+                                    t.returnStatement(t.logicalExpression('||', t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('__getShadowRoot')), []), t.identifier('querySelector')), [t.stringLiteral(`[data-ref="${selector}"]`)]), t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('__getShadowRoot')), []), t.identifier('querySelector')), [t.stringLiteral(selector)])))
+                                ]));
+                                newMembers.push(getter);
+                                propsToRemove.push(memberPath);
+                            }
+                        }
+                        continue;
+                    }
+                    const reactiveDecoratorIndices = [];
+                    for (const [idx, dec] of decorators.entries()) {
+                        const name = t.isCallExpression(dec.expression) && t.isIdentifier(dec.expression.callee) ? dec.expression.callee.name : t.isIdentifier(dec.expression) ? dec.expression.name : null;
+                        if (name === 'Reactive' || name === 'Input') {
+                            reactiveDecoratorIndices.push(idx);
+                        }
+                    }
+                    if (reactiveDecoratorIndices.length === 0)
+                        continue;
+                    for (let i = reactiveDecoratorIndices.length - 1; i >= 0; i--) {
+                        decorators.splice(reactiveDecoratorIndices[i], 1);
+                    }
+                    if (!t.isIdentifier(propNode.key))
+                        continue;
+                    const propName = propNode.key.name;
+                    const privateName = `__${propName}`;
+                    const initialValue = propNode.value ?? t.identifier('undefined');
+                    state.needsPropertyImport = true;
+                    state.reactiveProperties?.add(propName);
+                    const privateField = t.classProperty(t.identifier(privateName), t.newExpression(t.identifier('Property'), [initialValue]));
+                    const getter = t.classMethod('get', t.identifier(propName), [], t.blockStatement([
+                        t.returnStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier(privateName)), t.identifier('getValue')), []))
+                    ]));
+                    const setter = t.classMethod('set', t.identifier(propName), [t.identifier('__v')], t.blockStatement([
+                        t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier(privateName)), t.identifier('setValue')), [t.identifier('__v')]))
+                    ]));
+                    propsToRemove.push(memberPath);
+                    newMembers.push(getter, setter);
+                    privateFields.push(privateField);
+                }
+                for (const p of propsToRemove) {
+                    p.remove();
+                }
+                for (const field of privateFields.reverse()) {
+                    path.unshiftContainer('body', field);
+                }
+                for (const member of newMembers.reverse()) {
+                    path.unshiftContainer('body', member);
+                }
+                if (pipeMethods.length > 0) {
+                    const pipeProperties = pipeMethods.map(({ pipeName, methodName }) => t.objectProperty(t.identifier(pipeName), t.arrowFunctionExpression([t.restElement(t.identifier('args'))], t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier(methodName)), t.identifier('apply')), [
+                        t.thisExpression(),
+                        t.identifier('args')
+                    ]))));
+                    const pipesProperty = t.classProperty(t.identifier('__pipes'), t.objectExpression(pipeProperties));
+                    path.unshiftContainer('body', pipesProperty);
+                }
+                const classDecl = path.parentPath;
+                const classNode = classDecl?.node;
+                const decorators = (classNode && 'decorators' in classNode ? classNode.decorators : null) ?? [];
+                const componentDecorator = decorators.find((dec) => t.isCallExpression(dec.expression) && t.isIdentifier(dec.expression.callee) && dec.expression.callee.name === 'Component');
+                if (componentDecorator && t.isCallExpression(componentDecorator.expression)) {
+                    const args = componentDecorator.expression.arguments;
+                    if (args.length > 0 && t.isObjectExpression(args[0])) {
+                        const [configObj] = args;
+                        const pipesProp = configObj.properties.find(p => t.isObjectProperty(p) && t.isIdentifier(p.key) && p.key.name === 'pipes');
+                        if (pipesProp && t.isObjectProperty(pipesProp) && t.isArrayExpression(pipesProp.value)) {
+                            const pipeClasses = pipesProp.value.elements.filter((el) => t.isIdentifier(el));
+                            if (pipeClasses.length > 0) {
+                                const simplePipeProperties = pipeClasses.map(pipeClass => t.objectProperty(t.memberExpression(pipeClass, t.identifier('__pipeName')), t.arrowFunctionExpression([
+                                    t.identifier('v'),
+                                    t.restElement(t.identifier('a'))
+                                ], t.callExpression(t.memberExpression(t.newExpression(pipeClass, []), t.identifier('transform')), [
+                                    t.identifier('v'),
+                                    t.spreadElement(t.identifier('a'))
+                                ])), true));
+                                const pipesFromClasses = t.classProperty(t.identifier('__pipes'), t.objectExpression(simplePipeProperties));
+                                path.unshiftContainer('body', pipesFromClasses);
+                            }
+                        }
+                    }
+                }
+                const reactiveProps = state.reactiveProperties ?? new Set();
+                const constructorStatements = [];
+                for (const updateMethodName of getterHostBindingUpdates) {
+                    constructorStatements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier(updateMethodName)), [])));
+                }
+                for (const { propName, privateName } of propertyHostBindingInits) {
+                    constructorStatements.push(t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier(propName)), t.memberExpression(t.thisExpression(), t.identifier(privateName)))));
+                }
+                for (const { methodName, watchedProps: mProps } of watchMethods) {
+                    constructorStatements.push(t.expressionStatement(t.unaryExpression('void', t.memberExpression(t.thisExpression(), t.identifier(methodName)))));
+                    for (const prop of mProps) {
+                        if (reactiveProps.has(prop)) {
+                            constructorStatements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier(`__${prop}`)), t.identifier('onChange')), t.identifier('subscribe')), [t.arrowFunctionExpression([], t.callExpression(t.memberExpression(t.thisExpression(), t.identifier(methodName)), []))])));
+                        }
+                    }
+                }
+                for (const { propName, watchedProps: wProps, callbackArg } of watchCalls) {
+                    const iife = [
+                        t.variableDeclaration('const', [t.variableDeclarator(t.identifier('__cb'), t.isExpression(callbackArg) ? callbackArg : t.identifier('undefined'))]),
+                        t.variableDeclaration('const', [t.variableDeclarator(t.identifier('__subs'), t.arrayExpression([]))])
+                    ];
+                    for (const prop of wProps) {
+                        if (reactiveProps.has(prop)) {
+                            iife.push(t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('__subs'), t.identifier('push')), [
+                                t.callExpression(t.memberExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier(`__${prop}`)), t.identifier('onChange')), t.identifier('subscribe')), [t.identifier('__cb')])
+                            ])));
+                        }
+                    }
+                    iife.push(t.expressionStatement(t.callExpression(t.identifier('__cb'), [])));
+                    iife.push(t.returnStatement(t.objectExpression([
+                        t.objectMethod('method', t.identifier('unsubscribe'), [], t.blockStatement([
+                            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('__subs'), t.identifier('forEach')), [
+                                t.arrowFunctionExpression([t.identifier('s')], t.callExpression(t.memberExpression(t.identifier('s'), t.identifier('unsubscribe')), []))
+                            ]))
+                        ]))
+                    ])));
+                    const watchClassProp = t.classProperty(t.identifier(propName), t.callExpression(t.arrowFunctionExpression([], t.blockStatement(iife)), []));
+                    path.pushContainer('body', watchClassProp);
+                }
+                for (const { methodName, eventName } of hostListeners) {
+                    const [baseEvent, ...modifiers] = eventName.split('.');
+                    let handlerBody = t.emptyStatement();
+                    if (modifiers.length > 0) {
+                        const conditions = modifiers.map(mod => {
+                            if (mod === 'enter')
+                                return t.binaryExpression('===', t.memberExpression(t.identifier('__ev'), t.identifier('key')), t.stringLiteral('Enter'));
+                            if (mod === 'escape')
+                                return t.binaryExpression('===', t.memberExpression(t.identifier('__ev'), t.identifier('key')), t.stringLiteral('Escape'));
+                            if (mod === 'space')
+                                return t.binaryExpression('===', t.memberExpression(t.identifier('__ev'), t.identifier('key')), t.stringLiteral(' '));
+                            return t.booleanLiteral(true);
+                        });
+                        const combinedCondition = conditions.reduce((acc, cond) => t.logicalExpression('&&', acc, cond), t.booleanLiteral(true));
+                        handlerBody = t.ifStatement(combinedCondition, t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier(methodName)), [t.identifier('__ev')])));
+                    }
+                    else {
+                        handlerBody = t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier(methodName)), [t.identifier('__ev')]));
+                    }
+                    constructorStatements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('addEventListener')), [
+                        t.stringLiteral(baseEvent),
+                        t.arrowFunctionExpression([t.identifier('__ev')], t.blockStatement([handlerBody]))
+                    ])));
+                }
+                if (constructorStatements.length > 0) {
+                    const constructor = path.node.body.find((m) => t.isClassMethod(m) && m.kind === 'constructor');
+                    if (constructor) {
+                        const superIndex = constructor.body.body.findIndex(stmt => t.isExpressionStatement(stmt) && t.isCallExpression(stmt.expression) && t.isSuper(stmt.expression.callee));
+                        constructor.body.body.splice(superIndex >= 0 ? superIndex + 1 : 0, 0, ...constructorStatements);
+                    }
+                    else {
+                        path.unshiftContainer('body', t.classMethod('constructor', t.identifier('constructor'), [], t.blockStatement([
+                            t.expressionStatement(t.callExpression(t.super(), [])), ...constructorStatements
+                        ])));
+                    }
+                }
+            }
+        }
+    };
+}

package/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/bin.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { Cli, parseArgs } from './Cli.js';
+const { options, args } = parseArgs(process.argv.slice(2));
+const cli = new Cli(options);
+cli.run(args)
+    .catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+});

package/fluff-esbuild-plugin.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from 'esbuild';
+export interface FluffPluginOptions {
+    srcDir: string;
+    minify?: boolean;
+    sourcemap?: boolean;
+}
+export declare function fluffPlugin(options: FluffPluginOptions): Plugin;
+//# sourceMappingURL=fluff-esbuild-plugin.d.ts.map

package/fluff-esbuild-plugin.js

@@ -0,0 +1,59 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { ComponentCompiler } from './ComponentCompiler.js';
+function findFluffSourcePath() {
+    const thisFile = fileURLToPath(import.meta.url);
+    const distDir = path.dirname(thisFile);
+    const cliPackageDir = path.dirname(distDir);
+    const packagesDir = path.dirname(cliPackageDir);
+    const fluffSrcPath = path.join(packagesDir, 'fluff', 'src');
+    if (fs.existsSync(path.join(fluffSrcPath, 'index.ts'))) {
+        return fluffSrcPath;
+    }
+    return null;
+}
+export function fluffPlugin(options) {
+    const compiler = new ComponentCompiler();
+    let componentsDiscovered = false;
+    const fluffSrcPath = findFluffSourcePath();
+    return {
+        name: 'fluff',
+        setup(build) {
+            build.onStart(async () => {
+                if (!componentsDiscovered) {
+                    await compiler.discoverComponents(options.srcDir);
+                    componentsDiscovered = true;
+                }
+            });
+            build.onLoad({ filter: /\.component\.ts$/ }, async (args) => {
+                const result = await compiler.compileComponentForBundle(args.path, options.minify, options.sourcemap);
+                return {
+                    contents: result.code,
+                    loader: 'js',
+                    resolveDir: path.dirname(args.path),
+                    watchFiles: result.watchFiles
+                };
+            });
+            if (fluffSrcPath) {
+                build.onResolve({ filter: /^@fluffjs\/fluff$/ }, () => {
+                    return { path: path.join(fluffSrcPath, 'index.ts') };
+                });
+                build.onResolve({ filter: /^@fluffjs\/fluff\// }, (args) => {
+                    const subPath = args.path.replace('@fluffjs/fluff/', '');
+                    return { path: path.join(fluffSrcPath, subPath + '.ts') };
+                });
+                build.onResolve({ filter: /\.js$/ }, (args) => {
+                    if (args.resolveDir.includes(fluffSrcPath)) {
+                        const tsPath = path.join(args.resolveDir, args.path.replace('.js', '.ts'));
+                        if (args.path.includes('types/component')) {
+                            return { path: args.path, external: true };
+                        }
+                        return { path: tsPath };
+                    }
+                    return null;
+                });
+            }
+        }
+    };
+}

package/index.d.ts

@@ -0,0 +1,7 @@
+export { ComponentCompiler } from './ComponentCompiler.js';
+export { TemplateParser } from './TemplateParser.js';
+export { CodeGenerator } from './CodeGenerator.js';
+export { Cli, parseArgs } from './Cli.js';
+export type * from './types.js';
+export type * from './types/FluffConfig.js';
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,4 @@
+export { ComponentCompiler } from './ComponentCompiler.js';
+export { TemplateParser } from './TemplateParser.js';
+export { CodeGenerator } from './CodeGenerator.js';
+export { Cli, parseArgs } from './Cli.js';

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@fluffjs/cli",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "bin": {
+    "fluff": "./bin.js"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "*.js",
+    "*.d.ts",
+    "!*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "@babel/core": "^7.24.0",
+    "@babel/generator": "^7.24.0",
+    "@babel/parser": "^7.24.0",
+    "@babel/traverse": "^7.24.0",
+    "@babel/types": "^7.24.0",
+    "esbuild": "^0.20.0",
+    "html-minifier-terser": "^7.2.0",
+    "parse5": "^7.1.0",
+    "source-map": "^0.7.4",
+    "tslib": "^2.3.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/types.d.ts

@@ -0,0 +1,46 @@
+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

package/types.js

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