@fluffjs/cli 0.4.4 → 0.5.0

package/TemplateParser.js

@@ -10,10 +10,14 @@ export class TemplateParser {
     templateRefs = new Set();
     scopeStack = [];
     getterDependencyMap = new Map();
+    scopeElements = [];
     testYieldBeforeGetterDepsLookup = null;
     setGetterDependencyMap(map) {
         this.getterDependencyMap = map;
     }
+    setScopeElements(configs) {
+        this.scopeElements = configs;
+    }
     __setTestYieldBeforeGetterDepsLookup(callback) {
         this.testYieldBeforeGetterDepsLookup = callback;
     }
@@ -193,8 +197,59 @@ export class TemplateParser {
         else if (tagName === 'x-fluff-text') {
             return this.processTextElement(element);
         }
+        const scopeConfig = this.findScopeElementConfig(element);
+        if (scopeConfig) {
+            return this.processScopedElement(element, scopeConfig);
+        }
         return this.processRegularElement(element);
     }
+    findScopeElementConfig(element) {
+        for (const config of this.scopeElements) {
+            if (element.tagName === config.tagName && this.getAttr(element, config.letAttribute) !== null) {
+                return config;
+            }
+        }
+        return null;
+    }
+    async processScopedElement(element, config) {
+        const scopeVariable = this.getAttr(element, config.letAttribute) ?? '';
+        const bindings = [];
+        const attributes = {};
+        let hasBindings = false;
+        for (const attr of element.attrs) {
+            if (attr.name === config.letAttribute) {
+                continue;
+            }
+            if (attr.name.startsWith('x-fluff-attrib-')) {
+                const bindingInfo = await this.parseBindingAttribute(attr.value);
+                if (bindingInfo) {
+                    bindings.push(bindingInfo);
+                    hasBindings = true;
+                    if (bindingInfo.binding === 'ref') {
+                        this.templateRefs.add(bindingInfo.name);
+                    }
+                }
+            }
+            else {
+                attributes[attr.name] = attr.value;
+            }
+        }
+        this.pushScope(scopeVariable.split(',').map(v => v.trim()).filter(v => v.length > 0));
+        const children = await this.processNodes(element.childNodes ?? []);
+        this.popScope();
+        const node = {
+            type: 'element',
+            tagName: element.tagName,
+            attributes,
+            bindings,
+            children,
+            namespaceURI: element.namespaceURI
+        };
+        if (hasBindings) {
+            node.id = `l${this.bindingId++}`;
+        }
+        return node;
+    }
     async processForElement(element) {
         const iterator = this.getAttr(element, 'x-fluff-iterator') ?? 'item';
         const iterableRaw = this.getAttr(element, 'x-fluff-iterable') ?? '';

package/babel-plugin-directive.d.ts

@@ -0,0 +1,12 @@
+import type { PluginObj } from '@babel/core';
+export interface DirectiveMetadata {
+    selector: string;
+    className: string;
+}
+interface BabelPluginDirectiveState {
+    filename?: string;
+}
+export declare const directiveMetadataMap: Map<string, DirectiveMetadata>;
+export default function directivePlugin(): PluginObj<BabelPluginDirectiveState>;
+export {};
+//# sourceMappingURL=babel-plugin-directive.d.ts.map

package/babel-plugin-directive.js

@@ -0,0 +1,78 @@
+import { types as t } from '@babel/core';
+export const directiveMetadataMap = new Map();
+function getDecoratorName(decorator) {
+    if (t.isCallExpression(decorator.expression) && t.isIdentifier(decorator.expression.callee)) {
+        return decorator.expression.callee.name;
+    }
+    if (t.isIdentifier(decorator.expression)) {
+        return decorator.expression.name;
+    }
+    return null;
+}
+export default function directivePlugin() {
+    return {
+        name: 'babel-plugin-directive', visitor: {
+            ClassDeclaration(path, state) {
+                const decorators = path.node.decorators ?? [];
+                const directiveDecorator = decorators.find(dec => {
+                    if (t.isCallExpression(dec.expression)) {
+                        const { callee } = dec.expression;
+                        return t.isIdentifier(callee) && callee.name === 'Directive';
+                    }
+                    return false;
+                });
+                if (!directiveDecorator)
+                    return;
+                if (!t.isCallExpression(directiveDecorator.expression))
+                    return;
+                const args = directiveDecorator.expression.arguments;
+                if (args.length === 0)
+                    return;
+                const [configArg] = args;
+                if (!t.isObjectExpression(configArg))
+                    return;
+                const metadata = {};
+                if (path.node.id) {
+                    metadata.className = path.node.id.name;
+                }
+                for (const prop of configArg.properties) {
+                    if (!t.isObjectProperty(prop))
+                        continue;
+                    if (!t.isIdentifier(prop.key))
+                        continue;
+                    const key = prop.key.name;
+                    const { value } = prop;
+                    if (key === 'selector' && t.isStringLiteral(value)) {
+                        metadata.selector = value.value;
+                    }
+                }
+                const filename = state.filename ?? 'unknown';
+                if (metadata.selector && metadata.className) {
+                    directiveMetadataMap.set(filename, {
+                        selector: metadata.selector,
+                        className: metadata.className
+                    });
+                }
+                const hostElementProps = [];
+                const classBody = path.node.body.body;
+                for (const member of classBody) {
+                    if (!t.isClassProperty(member))
+                        continue;
+                    if (!t.isIdentifier(member.key))
+                        continue;
+                    const memberDecorators = member.decorators ?? [];
+                    const hostElementDecIdx = memberDecorators.findIndex(dec => getDecoratorName(dec) === 'HostElement');
+                    if (hostElementDecIdx !== -1) {
+                        hostElementProps.push(member.key.name);
+                        memberDecorators.splice(hostElementDecIdx, 1);
+                    }
+                }
+                if (hostElementProps.length > 0) {
+                    const assignments = hostElementProps.map(propName => t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier(propName)), t.identifier('hostElement'))));
+                    const setHostElementMethod = t.classMethod('method', t.identifier('__assignHostElementProps'), [t.identifier('hostElement')], t.blockStatement(assignments), false, false);
+                    classBody.push(setHostElementMethod);
+                }
+            }
+        }
+    };
+}

package/babel-plugin-reactive.js

@@ -356,6 +356,20 @@ export default function reactivePlugin() {
                     propsToRemove.push(memberPath);
                     privateFields.push(privateField);
                 }
+                const reactiveProps = state.reactiveProperties ?? new Set();
+                const constructorStatements = [];
+                for (const { propName, className, privateName } of classHostBindingDefs) {
+                    constructorStatements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('__defineClassHostBinding')), [t.stringLiteral(propName), t.stringLiteral(className), t.stringLiteral(privateName)])));
+                }
+                const initHostBindingsStatements = [];
+                for (const { updateMethodName, watchedProps } of getterHostBindingUpdates) {
+                    initHostBindingsStatements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier(updateMethodName)), [])));
+                    for (const prop of watchedProps) {
+                        if (reactiveProps.has(prop)) {
+                            initHostBindingsStatements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('__baseSubscriptions')), t.identifier('push')), [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(updateMethodName)), []))])])));
+                        }
+                    }
+                }
                 for (const p of propsToRemove) {
                     p.remove();
                 }
@@ -398,19 +412,6 @@ export default function reactivePlugin() {
                         }
                     }
                 }
-                const reactiveProps = state.reactiveProperties ?? new Set();
-                const constructorStatements = [];
-                for (const { propName, className, privateName } of classHostBindingDefs) {
-                    constructorStatements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('__defineClassHostBinding')), [t.stringLiteral(propName), t.stringLiteral(className), t.stringLiteral(privateName)])));
-                }
-                for (const { updateMethodName, watchedProps } of getterHostBindingUpdates) {
-                    constructorStatements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier(updateMethodName)), [])));
-                    for (const prop of watchedProps) {
-                        if (reactiveProps.has(prop)) {
-                            constructorStatements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('__baseSubscriptions')), t.identifier('push')), [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(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)))));
                 }
@@ -477,7 +478,7 @@ export default function reactivePlugin() {
                     }
                     const handlerFn = t.arrowFunctionExpression([t.identifier('__ev')], t.blockStatement([handlerBody]));
                     if (target === 'this') {
-                        constructorStatements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('addEventListener')), [
+                        initHostBindingsStatements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('__getHostElement')), []), t.identifier('addEventListener')), [
                             t.stringLiteral(baseEvent),
                             handlerFn
                         ])));
@@ -493,6 +494,10 @@ export default function reactivePlugin() {
                         globalListenerCleanups.push(t.expressionStatement(t.callExpression(t.memberExpression(target === 'document' ? t.identifier('document') : t.identifier('window'), t.identifier('removeEventListener')), [t.stringLiteral(baseEvent), t.memberExpression(t.thisExpression(), t.identifier(handlerPropName))])));
                     }
                 }
+                if (initHostBindingsStatements.length > 0) {
+                    const initHostBindingsMethod = t.classMethod('method', t.identifier('__initHostBindings'), [], t.blockStatement(initHostBindingsStatements));
+                    path.unshiftContainer('body', initHostBindingsMethod);
+                }
                 if (constructorStatements.length > 0) {
                     const constructor = path.node.body.find((m) => t.isClassMethod(m) && m.kind === 'constructor');
                     if (constructor) {

package/fluff-esbuild-plugin.js

@@ -1,8 +1,8 @@
+import { parse } from '@babel/parser';
+import * as t from '@babel/types';
 import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
-import { parse } from '@babel/parser';
-import * as t from '@babel/types';
 import { generate } from './BabelHelpers.js';
 import { CodeGenerator } from './CodeGenerator.js';
 import { ComponentCompiler } from './ComponentCompiler.js';
@@ -31,11 +31,10 @@ function getEntryPointPath(build) {
     return null;
 }
 function detectDecorators(source) {
-    const result = { hasComponent: false, hasPipe: false };
+    const result = { hasComponent: false, hasDirective: false, hasPipe: false };
     try {
         const ast = parse(source, {
-            sourceType: 'module',
-            plugins: ['typescript', 'decorators']
+            sourceType: 'module', plugins: ['typescript', 'decorators']
         });
         for (const node of ast.program.body) {
             if (t.isClassDeclaration(node) && node.decorators) {
@@ -44,6 +43,8 @@ function detectDecorators(source) {
                         const { name } = decorator.expression.callee;
                         if (name === 'Component')
                             result.hasComponent = true;
+                        if (name === 'Directive')
+                            result.hasDirective = true;
                         if (name === 'Pipe')
                             result.hasPipe = true;
                     }
@@ -55,6 +56,8 @@ function detectDecorators(source) {
                         const { name } = decorator.expression.callee;
                         if (name === 'Component')
                             result.hasComponent = true;
+                        if (name === 'Directive')
+                            result.hasDirective = true;
                         if (name === 'Pipe')
                             result.hasPipe = true;
                     }
@@ -66,6 +69,8 @@ function detectDecorators(source) {
                         const { name } = decorator.expression.callee;
                         if (name === 'Component')
                             result.hasComponent = true;
+                        if (name === 'Directive')
+                            result.hasDirective = true;
                         if (name === 'Pipe')
                             result.hasPipe = true;
                     }
@@ -82,20 +87,35 @@ export function fluffPlugin(options) {
     const fluffSrcPath = findFluffSourcePath();
     const compiledCache = new Map();
     let entryPointPath = null;
+    const { pluginManager } = options;
+    if (pluginManager) {
+        compiler.setPluginManager(pluginManager);
+    }
     // noinspection JSUnusedGlobalSymbols
     return {
-        name: 'fluff',
-        setup(build) {
+        name: 'fluff', setup(build) {
             entryPointPath = getEntryPointPath(build);
             build.onStart(async () => {
                 CodeGenerator.resetGlobalState();
                 compiledCache.clear();
                 const componentPaths = await compiler.discoverComponents(options.srcDir);
+                if (pluginManager?.hasPlugins) {
+                    await pluginManager.runAfterDiscovery({
+                        components: componentPaths.flatMap(p => {
+                            const metadata = compiler.getComponentMetadata(p);
+                            return metadata ? [{ filePath: p, metadata }] : [];
+                        }),
+                        directives: compiler.getDirectivePaths()
+                            .flatMap(p => {
+                            const metadata = compiler.getDirectiveMetadata(p);
+                            return metadata ? [{ filePath: p, metadata }] : [];
+                        })
+                    });
+                }
                 for (const componentPath of componentPaths) {
                     const result = await compiler.compileComponentForBundle(componentPath, options.minify, options.sourcemap, options.skipDefine, options.production);
                     compiledCache.set(componentPath, {
-                        code: result.code,
-                        watchFiles: result.watchFiles
+                        code: result.code, watchFiles: result.watchFiles
                     });
                 }
             });
@@ -120,40 +140,64 @@ export function fluffPlugin(options) {
                         watchFiles: result.watchFiles
                     };
                 }
+                if (decorators.hasDirective) {
+                    const result = await compiler.compileDirectiveForBundle(args.path, options.sourcemap, options.production);
+                    return {
+                        contents: result.code, loader: 'js', resolveDir: path.dirname(args.path)
+                    };
+                }
                 if (decorators.hasPipe) {
                     const transformed = await compiler.transformPipeDecorators(source, args.path);
                     DecoratorValidator.validate(transformed, args.path);
                     return {
-                        contents: transformed,
-                        loader: 'ts',
-                        resolveDir: path.dirname(args.path)
+                        contents: transformed, loader: 'ts', resolveDir: path.dirname(args.path)
                     };
                 }
                 if (!entryPointPath || args.path !== entryPointPath) {
                     return null;
                 }
                 const ast = parse(source, {
-                    sourceType: 'module',
-                    plugins: ['typescript', 'decorators']
+                    sourceType: 'module', plugins: ['typescript', 'decorators']
                 });
                 const exprTableImport = t.importDeclaration([], t.stringLiteral(VIRTUAL_EXPR_TABLE_ID));
                 ast.program.body.unshift(exprTableImport);
                 const output = generate(ast, { compact: false });
                 return {
-                    contents: output.code,
-                    loader: 'ts',
-                    resolveDir: path.dirname(args.path)
+                    contents: output.code, loader: 'ts', resolveDir: path.dirname(args.path)
                 };
             });
             build.onResolve({ filter: new RegExp(`^${VIRTUAL_EXPR_TABLE_ID.replace('/', '\\/')}$`) }, () => {
                 return { path: VIRTUAL_EXPR_TABLE_ID, namespace: 'fluff-virtual' };
             });
-            build.onLoad({ filter: /.*/, namespace: 'fluff-virtual' }, () => {
-                const exprTable = CodeGenerator.generateGlobalExprTable();
+            build.onLoad({ filter: /.*/, namespace: 'fluff-virtual' }, async () => {
+                const directivePaths = compiler.getDirectivePaths();
+                const directiveImports = directivePaths.map(p => `import '${p}';`)
+                    .join('\n');
+                const exprTable = CodeGenerator.generateGlobalExprTable(pluginManager);
+                let runtimeImports = '';
+                if (pluginManager?.hasPlugins) {
+                    const imports = pluginManager.collectRuntimeImports();
+                    runtimeImports = imports.map(imp => `import '${imp}';`)
+                        .join('\n');
+                }
+                let globalStylesCode = '';
+                if (options.globalStylesCss) {
+                    const escapedCss = options.globalStylesCss.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+                    globalStylesCode = 'import { FluffElement } from \'@fluffjs/fluff\';\n' +
+                        'const __fluffGlobalSheet = new CSSStyleSheet();\n' +
+                        `__fluffGlobalSheet.replaceSync(\`${escapedCss}\`);\n` +
+                        'FluffElement.__addGlobalStyleSheet(__fluffGlobalSheet);\n';
+                }
+                let entryContent = directiveImports + '\n' + runtimeImports + '\n' + globalStylesCode + (exprTable || '');
+                if (pluginManager?.hasPlugins) {
+                    const entryAst = parse(entryContent, { sourceType: 'module' });
+                    await pluginManager.runModifyEntryPoint({
+                        program: entryAst.program, srcDir: options.srcDir
+                    });
+                    entryContent = generate(entryAst, { compact: false }).code;
+                }
                 return {
-                    contents: exprTable || '',
-                    loader: 'js',
-                    resolveDir: options.srcDir
+                    contents: entryContent, loader: 'js', resolveDir: options.srcDir
                 };
             });
             if (fluffSrcPath) {

package/interfaces/ClassTransformContext.d.ts

@@ -0,0 +1,8 @@
+import type * as t from '@babel/types';
+import type { ComponentMetadata } from './ComponentMetadata.js';
+export interface ClassTransformContext {
+    ast: t.File;
+    filePath: string;
+    metadata: ComponentMetadata;
+}
+//# sourceMappingURL=ClassTransformContext.d.ts.map

package/interfaces/ClassTransformContext.js

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

package/interfaces/CodeGenContext.d.ts

@@ -0,0 +1,9 @@
+import type * as parse5 from 'parse5';
+import type { CompactBinding } from '../CodeGenerator.js';
+export interface CodeGenContext {
+    componentSelector: string;
+    generatedFragment: parse5.DefaultTreeAdapterMap['documentFragment'];
+    markerConfigs: Map<number, unknown>;
+    bindingsMap: Map<string, CompactBinding[]>;
+}
+//# sourceMappingURL=CodeGenContext.d.ts.map

package/interfaces/CodeGenContext.js

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

package/interfaces/DiscoveryInfo.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentMetadata } from './ComponentMetadata.js';
+import type { DirectiveMetadata } from '../babel-plugin-directive.js';
+export interface DiscoveryInfo {
+    components: ComponentDiscoveryEntry[];
+    directives: DirectiveDiscoveryEntry[];
+}
+export interface ComponentDiscoveryEntry {
+    filePath: string;
+    metadata: ComponentMetadata;
+}
+export interface DirectiveDiscoveryEntry {
+    filePath: string;
+    metadata: DirectiveMetadata;
+}
+//# sourceMappingURL=DiscoveryInfo.d.ts.map

package/interfaces/DiscoveryInfo.js

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

package/interfaces/EntryPointContext.d.ts

@@ -0,0 +1,6 @@
+import type * as t from '@babel/types';
+export interface EntryPointContext {
+    program: t.Program;
+    srcDir: string;
+}
+//# sourceMappingURL=EntryPointContext.d.ts.map

package/interfaces/EntryPointContext.js

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

package/interfaces/FluffConfigInterface.d.ts

@@ -3,5 +3,7 @@ export interface FluffConfig {
     version: string;
     targets: Record<string, FluffTarget>;
     defaultTarget?: string;
+    plugins?: string[];
+    pluginConfig?: Record<string, Record<string, unknown>>;
 }
 //# sourceMappingURL=FluffConfigInterface.d.ts.map

package/interfaces/FluffPlugin.d.ts

@@ -0,0 +1,26 @@
+import type * as parse5 from 'parse5';
+import type { FluffConfig } from './FluffConfigInterface.js';
+import type { DiscoveryInfo } from './DiscoveryInfo.js';
+import type { ParsedTemplate } from './ParsedTemplate.js';
+import type { CodeGenContext } from './CodeGenContext.js';
+import type { ClassTransformContext } from './ClassTransformContext.js';
+import type { EntryPointContext } from './EntryPointContext.js';
+import type { PluginHookName } from './PluginHookName.js';
+import type { PluginCustomTable } from './PluginCustomTable.js';
+import type { ScopeElementConfig } from './ScopeElementConfig.js';
+export interface FluffPlugin {
+    readonly name: string;
+    dependencies?: Partial<Record<PluginHookName, string[]>>;
+    afterConfig?: (config: FluffConfig, pluginConfig: Record<string, unknown>) => void | Promise<void>;
+    afterDiscovery?: (discovery: DiscoveryInfo) => void | Promise<void>;
+    beforeTemplatePreProcess?: (fragment: parse5.DefaultTreeAdapterMap['documentFragment'], componentSelector: string) => void | Promise<void>;
+    afterTemplateParse?: (template: ParsedTemplate, componentSelector: string) => void | Promise<void>;
+    afterCodeGeneration?: (context: CodeGenContext) => void | Promise<void>;
+    beforeClassTransform?: (context: ClassTransformContext) => void | Promise<void>;
+    modifyEntryPoint?: (context: EntryPointContext) => void | Promise<void>;
+    modifyIndexHtml?: (document: parse5.DefaultTreeAdapterMap['document']) => void | Promise<void>;
+    registerRuntimeImports?: () => string[];
+    registerCustomTables?: () => PluginCustomTable[];
+    registerScopeElements?: () => ScopeElementConfig[];
+}
+//# sourceMappingURL=FluffPlugin.d.ts.map

package/interfaces/FluffPlugin.js

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

package/interfaces/FluffPluginOptions.d.ts

@@ -1,3 +1,4 @@
+import type { PluginManager } from '../PluginManager.js';
 export interface FluffPluginOptions {
     srcDir: string;
     outDir?: string;
@@ -5,5 +6,7 @@ export interface FluffPluginOptions {
     sourcemap?: boolean;
     skipDefine?: boolean;
     production?: boolean;
+    pluginManager?: PluginManager;
+    globalStylesCss?: string;
 }
 //# sourceMappingURL=FluffPluginOptions.d.ts.map

package/interfaces/FluffTarget.d.ts

@@ -10,6 +10,7 @@ export interface FluffTarget {
     exclude?: string[];
     indexHtml?: string;
     styles?: string[];
+    globalStyles?: string[];
     assets?: string[];
     bundle?: BundleOptions;
     serve?: ServeOptions;

package/interfaces/HtmlTransformOptions.d.ts

@@ -1,3 +1,4 @@
+import type { PluginManager } from '../PluginManager.js';
 export interface HtmlTransformOptions {
     jsBundle: string;
     cssBundle?: string;
@@ -6,5 +7,6 @@ export interface HtmlTransformOptions {
     gzScriptTag?: boolean;
     minify?: boolean;
     liveReload?: boolean;
+    pluginManager?: PluginManager;
 }
 //# sourceMappingURL=HtmlTransformOptions.d.ts.map

package/interfaces/PluginCustomTable.d.ts

@@ -0,0 +1,6 @@
+import type * as t from '@babel/types';
+export interface PluginCustomTable {
+    name: string;
+    elements: t.Expression[];
+}
+//# sourceMappingURL=PluginCustomTable.d.ts.map

package/interfaces/PluginCustomTable.js

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

package/interfaces/PluginHookDependency.d.ts

@@ -0,0 +1,5 @@
+export interface PluginHookDependency {
+    pluginName?: string;
+    hookName?: string;
+}
+//# sourceMappingURL=PluginHookDependency.d.ts.map

package/interfaces/PluginHookDependency.js

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

package/interfaces/PluginHookName.d.ts

@@ -0,0 +1,2 @@
+export type PluginHookName = 'afterConfig' | 'afterDiscovery' | 'beforeTemplatePreProcess' | 'afterTemplateParse' | 'afterCodeGeneration' | 'beforeClassTransform' | 'modifyEntryPoint' | 'modifyIndexHtml' | 'registerRuntimeImports' | 'registerCustomTables' | 'registerScopeElements';
+//# sourceMappingURL=PluginHookName.d.ts.map

package/interfaces/PluginHookName.js

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

package/interfaces/ScopeElementConfig.d.ts

@@ -0,0 +1,5 @@
+export interface ScopeElementConfig {
+    readonly tagName: string;
+    readonly letAttribute: string;
+}
+//# sourceMappingURL=ScopeElementConfig.d.ts.map

package/interfaces/ScopeElementConfig.js

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

package/interfaces/index.d.ts

@@ -1,21 +1,28 @@
 export type { BindingInfo } from './BindingInfo.js';
 export type { BreakNode } from './BreakNode.js';
 export type { BundleOptions } from './BundleOptions.js';
+export type { ClassTransformContext } from './ClassTransformContext.js';
 export type { CliOptions } from './CliOptions.js';
 export type { ClassTransformOptions } from './ClassTransformOptions.js';
+export type { CodeGenContext } from './CodeGenContext.js';
 export type { CommentNode } from './CommentNode.js';
 export type { CompileResult } from './CompileResult.js';
 export type { CompilerOptions } from './CompilerOptions.js';
+export type { ComponentDiscoveryEntry, DirectiveDiscoveryEntry, DiscoveryInfo } from './DiscoveryInfo.js';
 export type { ComponentInfo } from './ComponentInfo.js';
 export type { ComponentMetadata } from './ComponentMetadata.js';
 export type { ControlFlow, SwitchCaseOld } from './ControlFlow.js';
 export type { ControlFlowNode } from './ControlFlowNode.js';
 export type { ElementNode } from './ElementNode.js';
+export type { EntryPointContext } from './EntryPointContext.js';
 export type { FluffConfig } from './FluffConfigInterface.js';
+export type { FluffPlugin } from './FluffPlugin.js';
 export type { FluffPluginOptions } from './FluffPluginOptions.js';
 export type { FluffTarget } from './FluffTarget.js';
 export type { ForNode } from './ForNode.js';
 export type { HtmlTransformOptions } from './HtmlTransformOptions.js';
+export type { PluginCustomTable } from './PluginCustomTable.js';
+export type { PluginHookName } from './PluginHookName.js';
 export type { IfBranch } from './IfBranch.js';
 export type { IfNode } from './IfNode.js';
 export type { ImportTransformOptions } from './ImportTransformOptions.js';
@@ -24,6 +31,7 @@ export type { ParsedTemplate } from './ParsedTemplate.js';
 export type { ParsedTemplateOld } from './ParsedTemplateOld.js';
 export type { PropertyChain } from './PropertyChain.js';
 export type { Scope } from './Scope.js';
+export type { ScopeElementConfig } from './ScopeElementConfig.js';
 export type { ServeOptions } from './ServeOptions.js';
 export type { SwitchCase } from './SwitchCase.js';
 export type { SwitchNode } from './SwitchNode.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluffjs/cli",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",
@@ -40,12 +40,14 @@
     "picomatch": "^4.0.2",
     "postcss": "^8.5.6",
     "source-map": "^0.7.6",
-    "tslib": "^2.3.0"
+    "tslib": "^2.3.0",
+    "ws": "^8.19.0"
   },
   "devDependencies": {
     "@types/he": "^1.2.3",
     "@types/http-proxy": "^1.17.16",
-    "@types/jsesc": "^3.0.3"
+    "@types/jsesc": "^3.0.3",
+    "@types/ws": "^8.18.1"
   },
   "publishConfig": {
     "access": "public"

package/PeerDependencies.d.ts

@@ -1,6 +0,0 @@
-export interface PeerDependency {
-    name: string;
-    version: string;
-}
-export declare function getCliPeerDependencies(): PeerDependency[];
-//# sourceMappingURL=PeerDependencies.d.ts.map

package/PeerDependencies.js

@@ -1,7 +0,0 @@
-export function getCliPeerDependencies() {
-    return [
-        { name: 'cssnano', version: '^7.1.2' },
-        { name: 'postcss', version: '^8.5.6' },
-        { name: 'jsesc', version: '^3.1.0' }
-    ];
-}