@dcoder-x/plugin-shared 0.1.3 → 0.1.5

package/dist/buildId.d.ts

@@ -0,0 +1,5 @@
+export interface ModuleGraphEntry {
+    id: string;
+    importedIds: readonly string[];
+}
+export declare function deriveBuildId(moduleGraph: Map<string, ModuleGraphEntry>): string;

package/dist/buildId.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveBuildId = deriveBuildId;
+function deriveBuildId(moduleGraph) {
+    if (!moduleGraph.size) {
+        return `vite_${Date.now()}`;
+    }
+    const rows = Array.from(moduleGraph.values())
+        .map((mod) => `${mod.id}|${[...mod.importedIds].sort().join(',')}`)
+        .sort()
+        .join('\n');
+    let hash = 0;
+    for (let i = 0; i < rows.length; i++) {
+        hash = (hash * 31 + rows.charCodeAt(i)) >>> 0;
+    }
+    return `vite_${hash.toString(36)}`;
+}

package/dist/extractors/ComponentContextResolver.d.ts

@@ -0,0 +1,37 @@
+import type { NodePath } from '@babel/traverse';
+export interface StateVariable {
+    name: string;
+    setter?: string;
+    initialValue?: string;
+    line: number;
+}
+export interface EventHandler {
+    name: string;
+    events: string[];
+    line: number;
+    callsStateSetters: string[];
+}
+export interface ComponentContext {
+    componentName: string;
+    stateVariables: StateVariable[];
+    eventHandlers: EventHandler[];
+}
+/**
+ * Resolves state declarations, setters, and event handlers within a component scope.
+ * This provides the symbol table needed for interaction graph extraction.
+ */
+export declare class ComponentContextResolver {
+    /**
+     * Extract state, handlers, and their relationships from a component AST node.
+     */
+    extractContext(componentPath: NodePath<any>, componentName: string): ComponentContext;
+    /**
+     * Extract handler name, event references, and called setters from a function.
+     */
+    private extractHandlerInfo;
+    /**
+     * Map event handlers referenced in JSX attributes to their handler definitions.
+     * Returns which state setters a given event attribute calls.
+     */
+    getStateSettersCalledByEvent(event: string, handlers: EventHandler[]): string[];
+}

package/dist/extractors/ComponentContextResolver.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentContextResolver = void 0;
+/**
+ * Resolves state declarations, setters, and event handlers within a component scope.
+ * This provides the symbol table needed for interaction graph extraction.
+ */
+class ComponentContextResolver {
+    /**
+     * Extract state, handlers, and their relationships from a component AST node.
+     */
+    extractContext(componentPath, componentName) {
+        const stateVariables = [];
+        const eventHandlers = [];
+        const stateSetterMap = new Map(); // setter -> state var
+        // First pass: collect useState declarations and build setter map
+        componentPath.traverse({
+            VariableDeclarator: (varPath) => {
+                const id = varPath.node.id;
+                const init = varPath.node.init;
+                // Detect useState pattern: const [state, setState] = useState(...)
+                if (id.type === 'ArrayPattern' &&
+                    id.elements &&
+                    id.elements.length === 2 &&
+                    init?.type === 'CallExpression') {
+                    const callee = init.callee;
+                    if ((callee.type === 'Identifier' && callee.name === 'useState') ||
+                        (callee.type === 'MemberExpression' && callee.property?.name === 'useState')) {
+                        const stateId = id.elements[0];
+                        const setterIdNode = id.elements[1];
+                        if (stateId?.type === 'Identifier' && setterIdNode?.type === 'Identifier') {
+                            const stateName = stateId.name;
+                            const setterName = setterIdNode.name;
+                            stateSetterMap.set(setterName, stateName);
+                            stateVariables.push({
+                                name: stateName,
+                                setter: setterName,
+                                initialValue: init.arguments?.[0]?.type === 'StringLiteral'
+                                    ? init.arguments[0].value
+                                    : undefined,
+                                line: varPath.node.loc?.start.line ?? 0,
+                            });
+                        }
+                    }
+                }
+                // Detect useReducer pattern: const [state, dispatch] = useReducer(...)
+                if (id.type === 'ArrayPattern' &&
+                    id.elements &&
+                    id.elements.length === 2 &&
+                    init?.type === 'CallExpression') {
+                    const callee = init.callee;
+                    if ((callee.type === 'Identifier' && callee.name === 'useReducer') ||
+                        (callee.type === 'MemberExpression' && callee.property?.name === 'useReducer')) {
+                        const stateId = id.elements[0];
+                        const dispatchIdNode = id.elements[1];
+                        if (stateId?.type === 'Identifier' && dispatchIdNode?.type === 'Identifier') {
+                            const stateName = stateId.name;
+                            const dispatchName = dispatchIdNode.name;
+                            stateSetterMap.set(dispatchName, stateName);
+                            stateVariables.push({
+                                name: stateName,
+                                setter: dispatchName,
+                                initialValue: undefined,
+                                line: varPath.node.loc?.start.line ?? 0,
+                            });
+                        }
+                    }
+                }
+            },
+        });
+        // Second pass: find event handler functions and track which setters they call
+        componentPath.traverse({
+            FunctionDeclaration: (funcPath) => {
+                const handlerInfo = this.extractHandlerInfo(funcPath, stateSetterMap);
+                if (handlerInfo) {
+                    handlerInfo.name = funcPath.node.id?.name || handlerInfo.name;
+                    eventHandlers.push(handlerInfo);
+                }
+            },
+            VariableDeclarator: (varPath) => {
+                if ((varPath.node.init?.type === 'ArrowFunctionExpression' ||
+                    varPath.node.init?.type === 'FunctionExpression') &&
+                    varPath.node.id?.type === 'Identifier') {
+                    const handlerName = varPath.node.id.name;
+                    const funcPath = varPath.get('init');
+                    const handlerInfo = this.extractHandlerInfo(funcPath, stateSetterMap);
+                    if (handlerInfo) {
+                        handlerInfo.name = handlerName;
+                        eventHandlers.push(handlerInfo);
+                    }
+                }
+            },
+        });
+        // Third pass: annotate which events correspond to each handler reference
+        componentPath.traverse({
+            JSXAttribute: (attrPath) => {
+                const name = attrPath.node.name?.name;
+                if (!name || !name.startsWith('on'))
+                    return;
+                const value = attrPath.node.value;
+                if (!value || value.type !== 'JSXExpressionContainer')
+                    return;
+                const expression = value.expression;
+                if (!expression)
+                    return;
+                const handlerName = expression.type === 'Identifier' ? expression.name : null;
+                if (!handlerName)
+                    return;
+                const handler = eventHandlers.find((h) => h.name === handlerName);
+                if (!handler)
+                    return;
+                if (!handler.events.includes(name)) {
+                    handler.events.push(name);
+                }
+            },
+        });
+        return {
+            componentName,
+            stateVariables,
+            eventHandlers,
+        };
+    }
+    /**
+     * Extract handler name, event references, and called setters from a function.
+     */
+    extractHandlerInfo(funcPath, stateSetterMap) {
+        const calledSetters = new Set();
+        funcPath.traverse({
+            CallExpression(callPath) {
+                const callee = callPath.node.callee;
+                let setterName = null;
+                if (callee.type === 'Identifier') {
+                    setterName = callee.name;
+                }
+                else if (callee.type === 'MemberExpression' && callee.property?.type === 'Identifier') {
+                    setterName = callee.property.name;
+                }
+                if (setterName && stateSetterMap.has(setterName)) {
+                    calledSetters.add(stateSetterMap.get(setterName));
+                }
+            },
+        });
+        return {
+            name: funcPath.node.id?.name || 'anonymous',
+            events: [],
+            line: funcPath.node.loc?.start.line ?? 0,
+            callsStateSetters: Array.from(calledSetters),
+        };
+    }
+    /**
+     * Map event handlers referenced in JSX attributes to their handler definitions.
+     * Returns which state setters a given event attribute calls.
+     */
+    getStateSettersCalledByEvent(event, handlers) {
+        // Simple heuristic: look for handlers named after the event
+        const candidates = handlers.filter((h) => h.name.toLowerCase().includes(event.toLowerCase().replace('on', '')) ||
+            h.events.includes(event));
+        const allSetters = new Set();
+        for (const handler of candidates) {
+            for (const setter of handler.callsStateSetters) {
+                allSetters.add(setter);
+            }
+        }
+        return Array.from(allSetters);
+    }
+}
+exports.ComponentContextResolver = ComponentContextResolver;

package/dist/extractors/ComponentExtractor.d.ts

@@ -1,9 +1,14 @@
-import type { ModuleGraphSource, DiscoveredRoute, DiscoveredElement } from '../types';
+import type { ModuleGraphSource, DiscoveredRoute, DiscoveredElement, PolicyComponent } from '../types';
 export declare class ComponentExtractor {
     private source;
     private routes;
     constructor(source: ModuleGraphSource, routes: DiscoveredRoute[]);
     extract(): Promise<DiscoveredElement[]>;
+    /**
+     * Extract component-level analysis including state, handlers, and interaction graphs.
+     * Returns PolicyComponent data suitable for policy document generation.
+     */
+    extractComponents(): Promise<PolicyComponent[]>;
     private getModuleFilesForRoute;
     private walkWebpackGraph;
     private findWebpackModule;

package/dist/extractors/ComponentExtractor.js

@@ -8,6 +8,10 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const parser_1 = require("@babel/parser");
 const traverse_1 = __importDefault(require("@babel/traverse"));
+const InteractionGraphExtractor_1 = require("./InteractionGraphExtractor");
+const ComponentContextResolver_1 = require("./ComponentContextResolver");
+const HtmlTagGuards_1 = require("../injection/HtmlTagGuards");
+const IdStrategy_1 = require("../injection/IdStrategy");
 class ComponentExtractor {
     constructor(source, routes) {
         this.source = source;
@@ -26,6 +30,66 @@ class ComponentExtractor {
         }
         return elements;
     }
+    /**
+     * Extract component-level analysis including state, handlers, and interaction graphs.
+     * Returns PolicyComponent data suitable for policy document generation.
+     */
+    async extractComponents() {
+        const components = [];
+        const contextResolver = new ComponentContextResolver_1.ComponentContextResolver();
+        const graphExtractor = new InteractionGraphExtractor_1.InteractionGraphExtractor();
+        for (const route of this.routes) {
+            const moduleFiles = this.getModuleFilesForRoute(route.filePath);
+            for (const filePath of moduleFiles) {
+                const source = this.readSource(filePath);
+                if (!source)
+                    continue;
+                let ast;
+                try {
+                    ast = (0, parser_1.parse)(source, { sourceType: 'module', plugins: ['typescript', 'jsx'] });
+                }
+                catch {
+                    continue;
+                }
+                // Find all component declarations and extract their analysis
+                (0, traverse_1.default)(ast, {
+                    FunctionDeclaration: (path) => {
+                        const componentName = path.node.id?.name;
+                        if (componentName && /^[A-Z]/.test(componentName)) {
+                            const context = contextResolver.extractContext(path, componentName);
+                            const interactions = graphExtractor.extractInteractions(path, componentName);
+                            components.push({
+                                name: componentName,
+                                filePath,
+                                route: route.path,
+                                stateVariables: context.stateVariables,
+                                interactions,
+                            });
+                        }
+                    },
+                    VariableDeclarator: (path) => {
+                        const componentName = path.node.id?.name;
+                        if (componentName &&
+                            /^[A-Z]/.test(componentName) &&
+                            (path.node.init?.type === 'ArrowFunctionExpression' ||
+                                path.node.init?.type === 'FunctionExpression')) {
+                            const funcPath = path.get('init');
+                            const context = contextResolver.extractContext(funcPath, componentName);
+                            const interactions = graphExtractor.extractInteractions(funcPath, componentName);
+                            components.push({
+                                name: componentName,
+                                filePath,
+                                route: route.path,
+                                stateVariables: context.stateVariables,
+                                interactions,
+                            });
+                        }
+                    },
+                });
+            }
+        }
+        return components;
+    }
     getModuleFilesForRoute(entryFilePath) {
         if (this.source.type === 'webpack') {
             return this.walkWebpackGraph(entryFilePath, this.source.compilation);
@@ -195,20 +259,32 @@ class ComponentExtractor {
                 const tagName = nodePath.node.name?.name;
                 if (!tagName)
                     return;
-                const isInteractive = ['button', 'input', 'select', 'textarea', 'a', 'form'].includes(tagName) ||
-                    nodePath.node.attributes.some((attr) => attr.type === 'JSXAttribute' && attr.name?.name === 'onClick');
-                if (!isInteractive)
+                // Navigation components (Link, NavLink) are included for flow graph building
+                // but flagged so the selector manifest skips them
+                const isNavigationComponent = (tagName === 'Link' || tagName === 'NavLink' || tagName === 'RouterLink') &&
+                    nodePath.node.attributes.some((a) => a.name?.name === 'href' || a.name?.name === 'to');
+                // Only intrinsic HTML tags get data-clippy-id injected; skip React components
+                if (!(0, HtmlTagGuards_1.isIntrinsicTag)(tagName) && !isNavigationComponent)
+                    return;
+                const INTERACTIVE_TAGS = new Set(['button', 'input', 'select', 'textarea', 'a', 'form', 'label']);
+                if (!isNavigationComponent && !INTERACTIVE_TAGS.has(tagName))
                     return;
                 const staticProps = extractStaticProps(nodePath.node.attributes);
                 const nearbyText = extractNearbyText(nodePath);
+                const label = deriveLabel(staticProps, nearbyText) ?? undefined;
+                const componentName = (0, IdStrategy_1.findEnclosingComponentName)(nodePath) ?? undefined;
                 elements.push({
                     tag: tagName,
                     filePath,
                     route,
                     staticProps,
                     nearbyText,
+                    label,
+                    component: componentName,
                     semanticRole: inferSemanticRole(tagName, staticProps, nearbyText),
                     interactions: inferInteractions(tagName, staticProps),
+                    loc: { line: nodePath.node.loc?.start?.line ?? 0 },
+                    isNavigationLink: isNavigationComponent,
                 });
             },
         });
@@ -268,18 +344,55 @@ function extractStaticProps(attributes) {
     return props;
 }
 function extractNearbyText(nodePath) {
-    const texts = [];
     const parent = nodePath.parentPath?.node;
-    if (parent?.children) {
-        for (const child of parent.children) {
-            if (child.type === 'JSXText') {
-                const text = child.value.trim();
-                if (text)
-                    texts.push(text);
+    if (!parent?.children)
+        return [];
+    return extractTextFromChildren(parent.children, 0);
+}
+function extractTextFromChildren(children, depth) {
+    if (depth > 3)
+        return [];
+    const texts = [];
+    for (const child of children) {
+        if (child.type === 'JSXText') {
+            const t = child.value.trim();
+            if (t)
+                texts.push(t);
+        }
+        else if (child.type === 'JSXExpressionContainer') {
+            if (child.expression?.type === 'StringLiteral') {
+                texts.push(child.expression.value);
+            }
+            else if (child.expression?.type === 'TemplateLiteral' &&
+                child.expression.quasis?.length === 1) {
+                const raw = child.expression.quasis[0].value.raw.trim();
+                if (raw)
+                    texts.push(raw);
+            }
+        }
+        else if (child.type === 'JSXElement') {
+            const childTag = child.openingElement?.name?.name || '';
+            // Skip icon-like leaf components — they contribute no readable text
+            if (!/^(Icon|Svg|Loader|Spinner|Arrow|Check|Plus|Minus|Close|X)[A-Z]?/i.test(childTag)) {
+                texts.push(...extractTextFromChildren(child.children || [], depth + 1));
             }
         }
     }
-    return texts;
+    return texts.filter(Boolean);
+}
+function deriveLabel(props, nearbyText) {
+    if (props['aria-label'])
+        return props['aria-label'];
+    if (props['title'])
+        return props['title'];
+    const joined = nearbyText.join(' ').trim();
+    if (joined && joined.length <= 60)
+        return joined;
+    if (props['placeholder'])
+        return props['placeholder'];
+    if (props['name'])
+        return props['name'];
+    return null;
 }
 function inferSemanticRole(tag, props, nearbyText) {
     const label = props['aria-label'] || props['placeholder'] || nearbyText[0] || '';

package/dist/extractors/FlowInferrer.d.ts

@@ -1,10 +1,13 @@
-import type { DiscoveredRoute, DiscoveredElement, InferredFlow } from '../types';
+import type { DiscoveredRoute, DiscoveredElement, InferredFlow, PolicyComponent } from '../types';
 export declare class FlowInferrer {
     private routes;
     private elements;
-    constructor(routes: DiscoveredRoute[], elements: DiscoveredElement[]);
+    private components?;
+    constructor(routes: DiscoveredRoute[], elements: DiscoveredElement[], components?: PolicyComponent[] | undefined);
     infer(): InferredFlow[];
     private buildEdgeGraph;
     private detectLinearFlows;
+    private detectInteractionFlows;
     private buildChain;
+    private generateIntentPatterns;
 }

package/dist/extractors/FlowInferrer.js

@@ -1,28 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowInferrer = void 0;
+const SEMANTIC_INTENT_PATTERNS = {
+    'login': ['log in', 'sign in', 'login'],
+    'signup': ['sign up', 'create account', 'register', 'get started'],
+    'register': ['register', 'sign up', 'create account'],
+    'forgot-password': ['forgot password', 'reset password', 'recover account'],
+    'reset-password': ['reset my password', 'set new password', 'change password'],
+    'verify': ['verify email', 'verify account', 'confirm email'],
+    'otp': ['enter code', 'verify code', 'enter otp'],
+    'billing': ['upgrade plan', 'manage billing', 'change subscription', 'view billing'],
+    'payment-method': ['add payment method', 'update card', 'change payment'],
+    'settings': ['settings', 'account settings', 'preferences'],
+    'team': ['invite team member', 'manage team', 'add team member'],
+    'forms': ['view forms', 'manage forms', 'create form', 'my forms'],
+    'builder': ['build form', 'form builder', 'edit form'],
+    'submissions': ['view submissions', 'form submissions', 'see responses'],
+    'analytics': ['view analytics', 'form analytics', 'see stats'],
+    'templates': ['view templates', 'browse templates', 'use template'],
+    'studio': ['template studio', 'create template'],
+    'transactions': ['view transactions', 'transaction history', 'payment history'],
+    'documents': ['view documents', 'open document', 'my documents'],
+    'integrations': ['integrations', 'connect integration', 'manage integrations'],
+    'developer': ['developer settings', 'api keys', 'developer dashboard'],
+    'automations': ['automations', 'manage automations', 'view automations'],
+    'campaigns': ['campaigns', 'view campaigns', 'manage campaigns'],
+    'website': ['website', 'manage website'],
+    'workflows': ['workflows', 'manage workflows'],
+    'invite': ['accept invite', 'join team'],
+};
 class FlowInferrer {
-    constructor(routes, elements) {
+    constructor(routes, elements, components) {
         this.routes = routes;
         this.elements = elements;
+        this.components = components;
     }
     infer() {
         const edges = this.buildEdgeGraph();
-        return this.detectLinearFlows(edges);
+        const routeFlows = this.detectLinearFlows(edges);
+        const interactionFlows = this.detectInteractionFlows();
+        return [...routeFlows, ...interactionFlows];
     }
     buildEdgeGraph() {
         const edges = [];
         const routePaths = new Set(this.routes.map((r) => r.path));
         for (const el of this.elements) {
+            // Include both native <a> tags and navigation components (Link, NavLink)
+            const isNav = el.tag === 'a' ||
+                el.isNavigationLink === true;
             const href = el.staticProps['href'] || el.staticProps['to'];
-            if (el.tag === 'a' && href && routePaths.has(href)) {
-                edges.push({
-                    from: el.route,
-                    to: href,
-                    trigger: el.staticProps['aria-label'] || el.nearbyText[0] || 'link',
-                    confidence: 0.85,
-                });
-            }
+            if (!isNav || !href)
+                continue;
+            // Only build edges to known internal routes
+            if (!routePaths.has(href))
+                continue;
+            const triggerText = el.staticProps['aria-label'] ||
+                el.label ||
+                el.nearbyText[0] ||
+                'link';
+            edges.push({
+                from: el.route,
+                to: href,
+                trigger: triggerText,
+                confidence: 0.85,
+            });
         }
         return edges;
     }
@@ -40,22 +81,63 @@ class FlowInferrer {
                 continue;
             const chain = this.buildChain(route.path, adjacency, new Set());
             if (chain.length >= 2) {
+                const chainEdges = edges.filter((e) => {
+                    const s = new Set(chain);
+                    return s.has(e.from) && s.has(e.to);
+                });
+                const intentPatterns = this.generateIntentPatterns(chain, chainEdges);
                 flows.push({
                     id: `flow_${flows.length + 1}`,
                     name: chain
                         .map((p) => p.split('/').filter(Boolean).pop() || 'home')
                         .join(' -> '),
+                    page: chain[0],
                     steps: chain,
-                    edges: edges.filter((e) => {
-                        const s = new Set(chain);
-                        return s.has(e.from) && s.has(e.to);
-                    }),
+                    edges: chainEdges,
+                    intentPatterns,
                 });
                 chain.forEach((p) => visited.add(p));
             }
         }
         return flows;
     }
+    detectInteractionFlows() {
+        if (!this.components || this.components.length === 0)
+            return [];
+        const flows = [];
+        for (const component of this.components) {
+            for (const interaction of component.interactions || []) {
+                // Only emit flows for interactions with a meaningful wait strategy
+                if (!interaction.trigger?.event)
+                    continue;
+                if (!interaction.effect || interaction.effect.waitStrategy === 'none')
+                    continue;
+                const routePath = component.route || '/';
+                const effectTarget = interaction.effect.selector ||
+                    (interaction.effect.rendersWhenTrue
+                        ? `[data-clippy-component='${interaction.effect.rendersWhenTrue}']`
+                        : null);
+                if (!effectTarget)
+                    continue;
+                flows.push({
+                    id: `flow_${flows.length + 1}`,
+                    name: interaction.effect.rendersWhenTrue || interaction.trigger.event,
+                    page: routePath,
+                    steps: [routePath],
+                    edges: [
+                        {
+                            from: routePath,
+                            to: routePath,
+                            trigger: interaction.trigger.event,
+                            confidence: 0.65,
+                        },
+                    ],
+                    intentPatterns: [],
+                });
+            }
+        }
+        return flows;
+    }
     buildChain(start, adjacency, seen) {
         if (seen.has(start))
             return [];
@@ -66,5 +148,26 @@ class FlowInferrer {
         const best = [...next].sort((a, b) => b.confidence - a.confidence)[0];
         return [start, ...this.buildChain(best.to, adjacency, seen)];
     }
+    generateIntentPatterns(chain, edges) {
+        const patterns = new Set();
+        // 1. Route-segment semantic lookup
+        for (const routePath of chain) {
+            const segments = routePath.split('/').filter(Boolean);
+            for (const segment of segments) {
+                const clean = segment.replace(/[\[\]$:]/g, '').toLowerCase();
+                const known = SEMANTIC_INTENT_PATTERNS[clean];
+                if (known)
+                    known.forEach((p) => patterns.add(p));
+            }
+        }
+        // 2. Link/button trigger text from the edges themselves
+        for (const edge of edges) {
+            const trigger = edge.trigger?.trim();
+            if (trigger && trigger !== 'link' && trigger.length > 2) {
+                patterns.add(trigger.toLowerCase());
+            }
+        }
+        return Array.from(patterns).filter(Boolean);
+    }
 }
 exports.FlowInferrer = FlowInferrer;

package/dist/extractors/InteractionGraphExtractor.d.ts

@@ -0,0 +1,28 @@
+import type { NodePath } from '@babel/traverse';
+import type { ComponentInteraction } from '../types';
+/**
+ * Extracts interaction graphs from React component ASTs.
+ * Maps event handlers -> state mutations -> conditional renders, navigation, and async effects.
+ */
+export declare class InteractionGraphExtractor {
+    private contextResolver;
+    /**
+     * Extract all interactions (trigger -> effect mappings) from a component.
+     */
+    extractInteractions(componentPath: NodePath<any>, componentName: string): ComponentInteraction[];
+    private buildInteractionFromSetters;
+    /**
+     * Detect router.push() / router.replace() / navigate() calls inside a handler.
+     * Returns the destination route string if found, otherwise null.
+     */
+    private resolveRouterNavigation;
+    private findHandlerBody;
+    private extractRouterCallFromNode;
+    private resolveStateSettersForAttribute;
+    private collectSettersFromNode;
+    private findConditionalEffect;
+    private findConditionalEffectInAncestors;
+    private findConditionalEffectInComponent;
+    private nodeReferencesState;
+    private extractComponentNameFromNode;
+}