@behavioral-contracts/verify-cli 1.0.0

package/dist/analyzers/event-listener-analyzer.js

@@ -0,0 +1,253 @@
+/**
+ * Event Listener Analyzer
+ *
+ * Detects missing required event listeners on instances of event-emitting classes.
+ * This is a PATTERN-BASED analyzer that works for ANY package requiring event listeners.
+ *
+ * Examples:
+ * - ws.WebSocket requires 'error' listener
+ * - bull.Queue requires 'error' and 'failed' listeners
+ * - archiver requires 'error' listener
+ * - socket.io.Server requires 'error' listener
+ *
+ * Contract Configuration:
+ * ```yaml
+ * detection:
+ *   class_names: ["WebSocket"]
+ *   require_instance_tracking: true
+ *   required_event_listeners:
+ *     - event: "error"
+ *       required: true
+ *       severity: error
+ * ```
+ */
+import * as ts from 'typescript';
+export class EventListenerAnalyzer {
+    sourceFile;
+    contracts;
+    // private typeChecker: ts.TypeChecker; // Reserved for future type-aware detection
+    // Track instances requiring event listeners
+    trackedInstances = new Map();
+    constructor(sourceFile, contracts, _typeChecker // Prefixed with _ to indicate intentionally unused
+    ) {
+        this.sourceFile = sourceFile;
+        this.contracts = contracts;
+        // this.typeChecker = typeChecker; // Reserved for future type-aware detection
+    }
+    /**
+     * Main analysis entry point
+     *
+     * Steps:
+     * 1. Find all instance declarations from contracts with required_event_listeners
+     * 2. Find all .on(), .addEventListener(), .once() calls for tracked instances
+     * 3. Check if all required listeners are attached
+     * 4. Report violations for missing required listeners
+     */
+    analyze(functionNode) {
+        const violations = [];
+        // Step 1: Find all instance declarations requiring event listeners
+        this.findInstanceDeclarations(functionNode);
+        // Step 2: Find all event listener attachments
+        this.findEventListeners(functionNode);
+        // Step 3: Validate all required listeners are attached
+        for (const [varName, instance] of this.trackedInstances.entries()) {
+            for (const requiredListener of instance.requiredListeners) {
+                if (!instance.attachedEvents.has(requiredListener.event)) {
+                    violations.push({
+                        packageName: instance.packageName,
+                        className: instance.className,
+                        variableName: varName,
+                        missingEvent: requiredListener.event,
+                        requiredListener,
+                        declarationNode: instance.declarationNode,
+                    });
+                }
+            }
+        }
+        // Clear tracking for next function
+        this.trackedInstances.clear();
+        return violations;
+    }
+    /**
+     * Find all instance declarations from contracts with required event listeners
+     *
+     * Patterns detected:
+     * - const ws = new WebSocket(url)
+     * - const queue = new Queue('tasks')
+     * - this.client = axios.create()
+     */
+    findInstanceDeclarations(node) {
+        const self = this;
+        function visit(node) {
+            // Pattern: const ws = new WebSocket(url)
+            if (ts.isVariableDeclaration(node) && node.initializer) {
+                self.checkNewExpression(node);
+            }
+            // Pattern: this.ws = new WebSocket(url)
+            if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+                if (ts.isNewExpression(node.right)) {
+                    self.checkNewExpressionForAssignment(node);
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(node);
+    }
+    /**
+     * Check if a new expression creates an instance requiring event listeners
+     */
+    checkNewExpression(declaration) {
+        if (!declaration.initializer || !ts.isNewExpression(declaration.initializer)) {
+            return;
+        }
+        const newExpr = declaration.initializer;
+        const className = this.getClassName(newExpr);
+        if (!className)
+            return;
+        // Check if any contract declares this class with required event listeners
+        for (const [packageName, contract] of this.contracts.entries()) {
+            if (!contract.detection?.required_event_listeners)
+                continue;
+            if (!contract.detection.class_names?.includes(className))
+                continue;
+            // This class requires event listeners - track it
+            const varName = declaration.name.getText(this.sourceFile);
+            this.trackedInstances.set(varName, {
+                packageName,
+                className,
+                requiredListeners: contract.detection.required_event_listeners,
+                declarationNode: declaration,
+                attachedEvents: new Set(),
+            });
+        }
+    }
+    /**
+     * Check assignment expressions like: this.ws = new WebSocket(url)
+     */
+    checkNewExpressionForAssignment(assignment) {
+        if (!ts.isNewExpression(assignment.right))
+            return;
+        const newExpr = assignment.right;
+        const className = this.getClassName(newExpr);
+        if (!className)
+            return;
+        // Check if any contract declares this class with required event listeners
+        for (const [packageName, contract] of this.contracts.entries()) {
+            if (!contract.detection?.required_event_listeners)
+                continue;
+            if (!contract.detection.class_names?.includes(className))
+                continue;
+            // Extract variable name from left side (e.g., "ws" from "this.ws")
+            const varName = this.getVariableNameFromExpression(assignment.left);
+            if (!varName)
+                return;
+            this.trackedInstances.set(varName, {
+                packageName,
+                className,
+                requiredListeners: contract.detection.required_event_listeners,
+                declarationNode: assignment,
+                attachedEvents: new Set(),
+            });
+        }
+    }
+    /**
+     * Extract class name from new expression
+     * Examples:
+     * - new WebSocket(url) → "WebSocket"
+     * - new Queue('tasks') → "Queue"
+     */
+    getClassName(newExpr) {
+        const expr = newExpr.expression;
+        if (ts.isIdentifier(expr)) {
+            return expr.text;
+        }
+        if (ts.isPropertyAccessExpression(expr)) {
+            return expr.name.text;
+        }
+        return null;
+    }
+    /**
+     * Extract variable name from expression
+     * Examples:
+     * - this.ws → "ws"
+     * - connection → "connection"
+     */
+    getVariableNameFromExpression(expr) {
+        if (ts.isIdentifier(expr)) {
+            return expr.text;
+        }
+        if (ts.isPropertyAccessExpression(expr)) {
+            return expr.name.text;
+        }
+        return null;
+    }
+    /**
+     * Find all event listener attachments
+     *
+     * Patterns detected:
+     * - ws.on('error', handler)
+     * - ws.addEventListener('error', handler)
+     * - ws.once('error', handler)
+     * - this.ws.on('error', handler)
+     */
+    findEventListeners(node) {
+        const self = this;
+        function visit(node) {
+            if (ts.isCallExpression(node)) {
+                self.checkEventListenerCall(node);
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(node);
+    }
+    /**
+     * Check if a call expression is attaching an event listener
+     */
+    checkEventListenerCall(call) {
+        // Must be a method call like ws.on(...)
+        if (!ts.isPropertyAccessExpression(call.expression)) {
+            return;
+        }
+        const propAccess = call.expression;
+        const methodName = propAccess.name.text;
+        // Only interested in event listener methods
+        if (!['on', 'addEventListener', 'once'].includes(methodName)) {
+            return;
+        }
+        // Extract variable name (e.g., "ws" from "ws.on(...)")
+        const varName = this.getVariableNameFromExpression(propAccess.expression);
+        if (!varName)
+            return;
+        // Check if this variable is tracked
+        const instance = this.trackedInstances.get(varName);
+        if (!instance)
+            return;
+        // Extract event name from first argument
+        const eventName = this.getEventName(call);
+        if (!eventName)
+            return;
+        // Mark this event as attached
+        instance.attachedEvents.add(eventName);
+    }
+    /**
+     * Extract event name from listener call
+     * Examples:
+     * - ws.on('error', handler) → "error"
+     * - ws.addEventListener("message", handler) → "message"
+     */
+    getEventName(call) {
+        if (call.arguments.length === 0)
+            return null;
+        const firstArg = call.arguments[0];
+        // String literal: 'error'
+        if (ts.isStringLiteral(firstArg)) {
+            return firstArg.text;
+        }
+        // No string literal: "message"
+        if (ts.isNoSubstitutionTemplateLiteral(firstArg)) {
+            return firstArg.text;
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=event-listener-analyzer.js.map

package/dist/analyzers/event-listener-analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-listener-analyzer.js","sourceRoot":"","sources":["../../src/analyzers/event-listener-analyzer.ts"],"names":[],"mappings":"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"}

package/dist/analyzers/react-query-analyzer.d.ts

@@ -0,0 +1,66 @@
+/**
+ * React Query specific analyzer
+ * Detects error handling patterns for useQuery, useMutation, useInfiniteQuery
+ */
+import * as ts from 'typescript';
+import type { HookCall, VariableUsage, HookErrorHandling } from '../types.js';
+export declare class ReactQueryAnalyzer {
+    private sourceFile;
+    constructor(sourceFile: ts.SourceFile, _checker: ts.TypeChecker);
+    /**
+     * Detects if a call expression is a React Query hook
+     */
+    isReactQueryHook(node: ts.CallExpression): string | null;
+    /**
+     * Detects if a new expression is QueryClient
+     */
+    isQueryClient(node: ts.NewExpression): boolean;
+    /**
+     * Extracts hook call information including options and return values
+     */
+    extractHookCall(node: ts.CallExpression, hookName: string): HookCall | null;
+    /**
+     * Parses hook options object to detect callbacks
+     */
+    private parseHookOptions;
+    /**
+     * Parses retry option to determine type
+     */
+    private parseRetryOption;
+    /**
+     * Parses destructured return values from hook
+     */
+    private parseReturnValues;
+    /**
+     * Tracks how a variable is used in the component scope
+     */
+    trackVariableUsage(variableName: string, componentNode: ts.Node): VariableUsage;
+    /**
+     * Checks if an expression references a specific variable
+     */
+    private referencesVariable;
+    /**
+     * Analyzes error handling for a React Query hook call
+     */
+    analyzeHookErrorHandling(hookCall: HookCall, componentNode: ts.Node): HookErrorHandling;
+    /**
+     * Finds the component (function) containing a node
+     */
+    findContainingComponent(node: ts.Node): ts.Node | null;
+    /**
+     * Heuristic to check if a function looks like a React component
+     */
+    private looksLikeComponent;
+    /**
+     * Detects QueryClient configuration and global error handlers
+     */
+    detectGlobalHandlers(sourceFile: ts.SourceFile): {
+        hasQueryCacheOnError: boolean;
+        hasMutationCacheOnError: boolean;
+    };
+    /**
+     * Checks if a QueryCache/MutationCache has onError callback
+     */
+    private hasOnErrorCallback;
+}
+//# sourceMappingURL=react-query-analyzer.d.ts.map

package/dist/analyzers/react-query-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-query-analyzer.d.ts","sourceRoot":"","sources":["../../src/analyzers/react-query-analyzer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAE9E,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,UAAU,CAAgB;gBAEtB,UAAU,EAAE,EAAE,CAAC,UAAU,EAAE,QAAQ,EAAE,EAAE,CAAC,WAAW;IAI/D;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,GAAG,MAAM,GAAG,IAAI;IAexD;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,aAAa,GAAG,OAAO;IAQ9C;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI;IA+B3E;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAwBxB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAaxB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAqBzB;;OAEG;IACH,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,CAAC,IAAI,GAAG,aAAa;IA0D/E;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA2B1B;;OAEG;IACH,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC,IAAI,GAAG,iBAAiB;IAgDvF;;OAEG;IACH,uBAAuB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,IAAI,GAAG,IAAI;IAiBtD;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAmB1B;;OAEG;IACH,oBAAoB,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG;QAC/C,oBAAoB,EAAE,OAAO,CAAC;QAC9B,uBAAuB,EAAE,OAAO,CAAC;KAClC;IAoCD;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAgB3B"}

package/dist/analyzers/react-query-analyzer.js

@@ -0,0 +1,341 @@
+/**
+ * React Query specific analyzer
+ * Detects error handling patterns for useQuery, useMutation, useInfiniteQuery
+ */
+import * as ts from 'typescript';
+export class ReactQueryAnalyzer {
+    sourceFile;
+    constructor(sourceFile, _checker) {
+        this.sourceFile = sourceFile;
+    }
+    /**
+     * Detects if a call expression is a React Query hook
+     */
+    isReactQueryHook(node) {
+        if (!ts.isIdentifier(node.expression)) {
+            return null;
+        }
+        const functionName = node.expression.text;
+        const reactQueryHooks = ['useQuery', 'useMutation', 'useInfiniteQuery'];
+        if (reactQueryHooks.includes(functionName)) {
+            return functionName;
+        }
+        return null;
+    }
+    /**
+     * Detects if a new expression is QueryClient
+     */
+    isQueryClient(node) {
+        if (!ts.isIdentifier(node.expression)) {
+            return false;
+        }
+        return node.expression.text === 'QueryClient';
+    }
+    /**
+     * Extracts hook call information including options and return values
+     */
+    extractHookCall(node, hookName) {
+        const location = this.sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        const hookCall = {
+            hookName: hookName,
+            location: {
+                file: this.sourceFile.fileName,
+                line: location.line + 1,
+                column: location.character + 1,
+            },
+            returnValues: new Map(),
+            options: {},
+        };
+        // Extract options object (first argument for hooks)
+        if (node.arguments.length > 0) {
+            const optionsArg = node.arguments[0];
+            if (ts.isObjectLiteralExpression(optionsArg)) {
+                this.parseHookOptions(optionsArg, hookCall);
+            }
+        }
+        // Extract return values from destructuring
+        const parent = node.parent;
+        if (parent && ts.isVariableDeclaration(parent)) {
+            this.parseReturnValues(parent, hookCall);
+        }
+        return hookCall;
+    }
+    /**
+     * Parses hook options object to detect callbacks
+     */
+    parseHookOptions(options, hookCall) {
+        for (const property of options.properties) {
+            if (!ts.isPropertyAssignment(property))
+                continue;
+            if (!ts.isIdentifier(property.name))
+                continue;
+            const propName = property.name.text;
+            switch (propName) {
+                case 'onError':
+                    hookCall.options.onError = true;
+                    break;
+                case 'onMutate':
+                    hookCall.options.onMutate = true;
+                    break;
+                case 'onSuccess':
+                    hookCall.options.onSuccess = true;
+                    break;
+                case 'retry':
+                    hookCall.options.retry = this.parseRetryOption(property.initializer);
+                    break;
+            }
+        }
+    }
+    /**
+     * Parses retry option to determine type
+     */
+    parseRetryOption(node) {
+        if (ts.isNumericLiteral(node)) {
+            return 'number';
+        }
+        if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) {
+            return 'boolean';
+        }
+        if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+            return 'function';
+        }
+        return 'default';
+    }
+    /**
+     * Parses destructured return values from hook
+     */
+    parseReturnValues(declaration, hookCall) {
+        if (!declaration.name || !ts.isObjectBindingPattern(declaration.name)) {
+            return;
+        }
+        for (const element of declaration.name.elements) {
+            if (!ts.isBindingElement(element))
+                continue;
+            // Handle both: { error } and { error: customError }
+            const propertyName = element.propertyName
+                ? (ts.isIdentifier(element.propertyName) ? element.propertyName.text : '')
+                : (ts.isIdentifier(element.name) ? element.name.text : '');
+            const variableName = ts.isIdentifier(element.name) ? element.name.text : '';
+            if (propertyName && variableName) {
+                hookCall.returnValues.set(variableName, propertyName);
+            }
+        }
+    }
+    /**
+     * Tracks how a variable is used in the component scope
+     */
+    trackVariableUsage(variableName, componentNode) {
+        const usage = {
+            variableName,
+            propertyName: '',
+            declaredAt: {
+                file: this.sourceFile.fileName,
+                line: 0,
+            },
+            usedIn: {
+                conditionals: 0,
+                jsxExpressions: 0,
+                callbacks: 0,
+            },
+        };
+        const self = this;
+        // Walk the component to find variable usage
+        function visit(node) {
+            // Check for if statements: if (isError) { ... }
+            if (ts.isIfStatement(node)) {
+                const condition = node.expression;
+                if (self.referencesVariable(condition, variableName)) {
+                    usage.usedIn.conditionals++;
+                }
+            }
+            // Check for ternary: isError ? <Error /> : <Success />
+            if (ts.isConditionalExpression(node)) {
+                if (self.referencesVariable(node.condition, variableName)) {
+                    usage.usedIn.conditionals++;
+                }
+            }
+            // Check for JSX: {isError && <Error />}
+            if (ts.isJsxExpression(node)) {
+                if (node.expression && self.referencesVariable(node.expression, variableName)) {
+                    usage.usedIn.jsxExpressions++;
+                }
+            }
+            // Check for logical expressions: isError && doSomething()
+            if (ts.isBinaryExpression(node)) {
+                if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+                    node.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+                    if (self.referencesVariable(node.left, variableName)) {
+                        usage.usedIn.conditionals++;
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(componentNode);
+        return usage;
+    }
+    /**
+     * Checks if an expression references a specific variable
+     */
+    referencesVariable(node, variableName) {
+        if (ts.isIdentifier(node) && node.text === variableName) {
+            return true;
+        }
+        // Check for property access: error.message
+        if (ts.isPropertyAccessExpression(node)) {
+            if (ts.isIdentifier(node.expression) && node.expression.text === variableName) {
+                return true;
+            }
+        }
+        // Check for optional chaining: error?.message
+        if (ts.isNonNullExpression(node)) {
+            return this.referencesVariable(node.expression, variableName);
+        }
+        let found = false;
+        ts.forEachChild(node, (child) => {
+            if (this.referencesVariable(child, variableName)) {
+                found = true;
+            }
+        });
+        return found;
+    }
+    /**
+     * Analyzes error handling for a React Query hook call
+     */
+    analyzeHookErrorHandling(hookCall, componentNode) {
+        const analysis = {
+            hasErrorStateCheck: false,
+            hasOnErrorCallback: false,
+            hasGlobalHandler: false, // TODO: Detect from QueryClient
+            errorCheckedBeforeDataAccess: false,
+        };
+        // Check if onError callback is present
+        if (hookCall.options.onError) {
+            analysis.hasOnErrorCallback = true;
+        }
+        // Track error/isError variables
+        const errorVars = Array.from(hookCall.returnValues.entries())
+            .filter(([_, propName]) => propName === 'error' || propName === 'isError')
+            .map(([varName, _]) => varName);
+        // Check if any error variables are used
+        for (const errorVar of errorVars) {
+            const usage = this.trackVariableUsage(errorVar, componentNode);
+            if (usage.usedIn.conditionals > 0 || usage.usedIn.jsxExpressions > 0) {
+                analysis.hasErrorStateCheck = true;
+                break;
+            }
+        }
+        // Check for optimistic update pattern (onMutate + onError)
+        if (hookCall.hookName === 'useMutation') {
+            if (hookCall.options.onMutate && hookCall.options.onError) {
+                // TODO: Verify rollback logic in onError
+                analysis.hasOptimisticUpdateRollback = true;
+            }
+            else if (hookCall.options.onMutate && !hookCall.options.onError) {
+                analysis.hasOptimisticUpdateRollback = false;
+            }
+        }
+        // Analyze retry configuration
+        if (hookCall.options.retry) {
+            analysis.retryAnalysis = {
+                type: hookCall.options.retry,
+                avoidsClientErrors: hookCall.options.retry === 'function', // Assume function checks status
+            };
+        }
+        return analysis;
+    }
+    /**
+     * Finds the component (function) containing a node
+     */
+    findContainingComponent(node) {
+        let current = node.parent;
+        while (current) {
+            // Check for function component
+            if (ts.isFunctionDeclaration(current) ||
+                ts.isFunctionExpression(current) ||
+                ts.isArrowFunction(current)) {
+                // Verify it looks like a React component (PascalCase name or returns JSX)
+                if (this.looksLikeComponent(current)) {
+                    return current;
+                }
+            }
+            current = current.parent;
+        }
+        return null;
+    }
+    /**
+     * Heuristic to check if a function looks like a React component
+     */
+    looksLikeComponent(node) {
+        // Check for PascalCase name
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            const name = node.name.text;
+            if (name && name[0] === name[0].toUpperCase()) {
+                return true;
+            }
+        }
+        // Check if it returns JSX
+        // This is a simplified check - a full check would need to walk the function body
+        const bodyText = node.body?.getText(this.sourceFile) || '';
+        if (bodyText.includes('<') && bodyText.includes('/>')) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Detects QueryClient configuration and global error handlers
+     */
+    detectGlobalHandlers(sourceFile) {
+        const result = {
+            hasQueryCacheOnError: false,
+            hasMutationCacheOnError: false,
+        };
+        const self = this;
+        function visit(node) {
+            // Look for: new QueryClient({ ... })
+            if (ts.isNewExpression(node) && self.isQueryClient(node)) {
+                if (node.arguments && node.arguments.length > 0) {
+                    const config = node.arguments[0];
+                    if (ts.isObjectLiteralExpression(config)) {
+                        // Check for queryCache and mutationCache
+                        for (const prop of config.properties) {
+                            if (!ts.isPropertyAssignment(prop))
+                                continue;
+                            if (!ts.isIdentifier(prop.name))
+                                continue;
+                            if (prop.name.text === 'queryCache') {
+                                result.hasQueryCacheOnError = self.hasOnErrorCallback(prop.initializer);
+                            }
+                            else if (prop.name.text === 'mutationCache') {
+                                result.hasMutationCacheOnError = self.hasOnErrorCallback(prop.initializer);
+                            }
+                        }
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(sourceFile);
+        return result;
+    }
+    /**
+     * Checks if a QueryCache/MutationCache has onError callback
+     */
+    hasOnErrorCallback(node) {
+        // Look for: new QueryCache({ onError: ... })
+        if (ts.isNewExpression(node) && node.arguments && node.arguments.length > 0) {
+            const config = node.arguments[0];
+            if (ts.isObjectLiteralExpression(config)) {
+                for (const prop of config.properties) {
+                    if (ts.isPropertyAssignment(prop) &&
+                        ts.isIdentifier(prop.name) &&
+                        prop.name.text === 'onError') {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=react-query-analyzer.js.map