@rayburst/cli 0.1.17 → 0.2.0

package/dist/analysis/analyze-project.js

@@ -0,0 +1,440 @@
+import { Project, SyntaxKind, Node } from 'ts-morph';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import crypto from 'crypto';
+/**
+ * Analyze a TypeScript/React project and generate nodes/edges data
+ * @param {string} projectPath - Absolute path to project root
+ * @param {string} projectId - Project ID
+ * @param {function} onLog - Callback for logging
+ * @returns {Promise<AnalysisResult>} Analysis data with nodes and edges
+ */
+export async function analyzeProject(projectPath, projectId, onLog) {
+    const logs = [];
+    const log = (message) => {
+        console.log(message);
+        logs.push(message);
+        // Call the callback if provided (for real-time streaming)
+        if (onLog) {
+            onLog(message);
+        }
+    };
+    log(`Analyzing project at: ${projectPath}`);
+    const gitHash = getGitHash(projectPath);
+    const gitInfo = getGitInfo(projectPath);
+    log(`  Git hash: ${gitHash}`);
+    log(`  Current branch: ${gitInfo.branch}`);
+    // Find tsconfig.json
+    const tsconfigPath = path.join(projectPath, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath)) {
+        log(`  Warning: No tsconfig.json found, skipping TypeScript analysis`);
+        const emptyAnalysis = createEmptyAnalysis(projectPath, gitInfo);
+        emptyAnalysis.logs = logs;
+        return emptyAnalysis;
+    }
+    try {
+        // Initialize ts-morph project
+        const project = new Project({
+            tsConfigFilePath: tsconfigPath,
+        });
+        const nodes = [];
+        const edges = [];
+        const nodeMap = new Map();
+        const usedIds = new Set();
+        const idCounters = new Map();
+        // Track file positions for layout
+        let fileIndex = 0;
+        const filePositions = new Map();
+        // Get all source files (excluding node_modules, test files)
+        const sourceFiles = project.getSourceFiles()
+            .filter(sf => {
+            const filePath = sf.getFilePath();
+            return !filePath.includes('node_modules') &&
+                !filePath.includes('.test.') &&
+                !filePath.includes('.spec.') &&
+                (filePath.endsWith('.ts') || filePath.endsWith('.tsx'));
+        });
+        log(`  Analyzing ${sourceFiles.length} source files...`);
+        // Analyze each source file
+        for (let i = 0; i < sourceFiles.length; i++) {
+            const sourceFile = sourceFiles[i];
+            const filePath = sourceFile.getFilePath();
+            const relativePath = filePath.replace(projectPath + '/', '');
+            if (!filePositions.has(relativePath)) {
+                filePositions.set(relativePath, fileIndex++);
+            }
+            const baseX = (filePositions.get(relativePath) || 0) * 400;
+            let nodeY = 100;
+            // Extract React components
+            const components = extractComponents(sourceFile, relativePath, gitHash, baseX, nodeY, nodes, nodeMap, usedIds, idCounters);
+            nodeY += components * 150;
+            // Extract functions
+            const functions = extractFunctions(sourceFile, relativePath, gitHash, baseX, nodeY, nodes, nodeMap, usedIds, idCounters);
+            nodeY += functions * 150;
+            // Extract state declarations
+            const states = extractState(sourceFile, relativePath, gitHash, baseX, nodeY, nodes, nodeMap, usedIds, idCounters);
+            nodeY += states * 150;
+            // Yield to event loop every 10 files to allow SSE streaming
+            if (i % 10 === 0 && i > 0) {
+                await new Promise(resolve => setImmediate(resolve));
+            }
+        }
+        log(`  Extracted ${nodes.length} nodes`);
+        // Generate edges by analyzing relationships
+        for (const sourceFile of sourceFiles) {
+            generateEdges(sourceFile, nodeMap, edges);
+        }
+        log(`  Generated ${edges.length} edges`);
+        // Read package.json for project metadata
+        const packageJsonPath = path.join(projectPath, 'package.json');
+        let packageJson = { name: path.basename(projectPath) };
+        if (fs.existsSync(packageJsonPath)) {
+            packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        }
+        const branchId = gitInfo.branch.replace(/[^a-zA-Z0-9]/g, '-');
+        const projectMetadata = {
+            id: projectId || crypto.createHash('md5').update(projectPath).digest('hex').substring(0, 12),
+            title: packageJson.name || path.basename(projectPath),
+            subtitle: new Date().toLocaleDateString(),
+            value: `${nodes.length} nodes`,
+            trend: 0,
+            chartData: [30, 40, 35, 50, 45, 60, 55, 70],
+            chartColor: '#22c55e',
+        };
+        const branchMetadata = {
+            id: branchId,
+            name: gitInfo.branch,
+            lastCommit: gitInfo.lastCommit,
+            lastCommitDate: 'just now',
+            author: gitInfo.author,
+            status: 'active',
+            commitCount: gitInfo.commitCount,
+            pullRequests: 0,
+        };
+        const planData = {
+            nodes,
+            edges,
+        };
+        const result = {
+            project: projectMetadata,
+            branches: [branchMetadata],
+            planData: {
+                [branchId]: planData
+            },
+            analyzedAt: new Date().toISOString(),
+            logs,
+        };
+        return result;
+    }
+    catch (error) {
+        console.error(`  Error analyzing project:`, error.message);
+        log(`  Error: ${error.message}`);
+        const emptyAnalysis = createEmptyAnalysis(projectPath, gitInfo);
+        emptyAnalysis.logs = logs;
+        return emptyAnalysis;
+    }
+}
+function createEmptyAnalysis(projectPath, gitInfo) {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    let packageJson = { name: path.basename(projectPath) };
+    if (fs.existsSync(packageJsonPath)) {
+        packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    }
+    const branchId = gitInfo.branch.replace(/[^a-zA-Z0-9]/g, '-');
+    return {
+        project: {
+            id: crypto.createHash('md5').update(projectPath).digest('hex').substring(0, 12),
+            title: packageJson.name || path.basename(projectPath),
+            subtitle: new Date().toLocaleDateString(),
+            value: '0 nodes',
+            trend: 0,
+            chartData: [],
+            chartColor: '#6b7280',
+        },
+        branches: [{
+                id: branchId,
+                name: gitInfo.branch,
+                lastCommit: gitInfo.lastCommit,
+                lastCommitDate: 'just now',
+                author: gitInfo.author,
+                status: 'active',
+                commitCount: gitInfo.commitCount,
+                pullRequests: 0,
+            }],
+        planData: {},
+        analyzedAt: new Date().toISOString(),
+    };
+}
+function getGitHash(projectPath) {
+    try {
+        return execSync('git rev-parse --short HEAD', { cwd: projectPath, encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return 'nogit';
+    }
+}
+function getGitInfo(projectPath) {
+    try {
+        const branch = execSync('git branch --show-current', { cwd: projectPath, encoding: 'utf-8' }).trim() || 'main';
+        const lastCommit = execSync('git log -1 --pretty=%s', { cwd: projectPath, encoding: 'utf-8' }).trim() || 'No commits';
+        const author = execSync('git log -1 --pretty=%an', { cwd: projectPath, encoding: 'utf-8' }).trim() || 'Unknown';
+        const commitCount = parseInt(execSync('git rev-list --count HEAD', { cwd: projectPath, encoding: 'utf-8' }).trim() || '0');
+        return { branch, lastCommit, author, commitCount };
+    }
+    catch {
+        return {
+            branch: 'main',
+            lastCommit: 'No commits',
+            author: 'Unknown',
+            commitCount: 0
+        };
+    }
+}
+function createNodeId(filePath, nodeName, gitHash, counter = 0) {
+    const suffix = counter > 0 ? `-${counter}` : '';
+    return `${filePath}::${nodeName}${suffix}::${gitHash}`;
+}
+function getUniqueNodeId(filePath, nodeName, gitHash, usedIds, idCounters) {
+    const baseKey = `${filePath}::${nodeName}`;
+    const counter = idCounters.get(baseKey) || 0;
+    const id = createNodeId(filePath, nodeName, gitHash, counter);
+    if (usedIds.has(id)) {
+        idCounters.set(baseKey, counter + 1);
+        return getUniqueNodeId(filePath, nodeName, gitHash, usedIds, idCounters);
+    }
+    usedIds.add(id);
+    idCounters.set(baseKey, counter + 1);
+    return id;
+}
+function isReactComponent(func) {
+    const body = func.getBody();
+    if (!body)
+        return false;
+    const text = body.getText();
+    return text.includes('return') && (text.includes('</') || text.includes('<>') || text.includes('jsx'));
+}
+function extractComponents(sourceFile, relativePath, gitHash, baseX, startY, nodes, nodeMap, usedIds, idCounters) {
+    let count = 0;
+    let y = startY;
+    // Find function components
+    const functions = sourceFile.getFunctions();
+    for (const func of functions) {
+        if (isReactComponent(func)) {
+            const name = func.getName() || 'AnonymousComponent';
+            const id = getUniqueNodeId(relativePath, name, gitHash, usedIds, idCounters);
+            const params = func.getParameters();
+            const propsParam = params[0];
+            const propsType = propsParam ? propsParam.getType().getText() : 'any';
+            const node = {
+                id,
+                type: 'component',
+                position: { x: baseX, y: y },
+                data: {
+                    componentName: name,
+                    props: propsType,
+                    label: name,
+                    description: `Component in ${relativePath}`,
+                }
+            };
+            nodes.push(node);
+            nodeMap.set(id, node);
+            nodeMap.set(name, node);
+            count++;
+            y += 150;
+        }
+    }
+    // Find arrow function components
+    const variables = sourceFile.getVariableDeclarations();
+    for (const variable of variables) {
+        const init = variable.getInitializer();
+        if (init && (Node.isArrowFunction(init) || Node.isFunctionExpression(init))) {
+            if (isReactComponent(init)) {
+                const name = variable.getName();
+                const id = getUniqueNodeId(relativePath, name, gitHash, usedIds, idCounters);
+                const params = init.getParameters();
+                const propsParam = params[0];
+                const propsType = propsParam ? propsParam.getType().getText() : 'any';
+                const node = {
+                    id,
+                    type: 'component',
+                    position: { x: baseX, y: y },
+                    data: {
+                        componentName: name,
+                        props: propsType,
+                        label: name,
+                        description: `Component in ${relativePath}`,
+                    }
+                };
+                nodes.push(node);
+                nodeMap.set(id, node);
+                nodeMap.set(name, node);
+                count++;
+                y += 150;
+            }
+        }
+    }
+    return count;
+}
+function extractFunctions(sourceFile, relativePath, gitHash, baseX, startY, nodes, nodeMap, usedIds, idCounters) {
+    let count = 0;
+    let y = startY;
+    const functions = sourceFile.getFunctions();
+    for (const func of functions) {
+        if (!isReactComponent(func)) {
+            const name = func.getName() || 'anonymous';
+            if (name === 'anonymous')
+                continue;
+            const id = getUniqueNodeId(relativePath, name, gitHash, usedIds, idCounters);
+            const params = func.getParameters().map((p) => {
+                const paramName = p.getName();
+                const paramType = p.getType().getText();
+                return `${paramName}: ${paramType}`;
+            }).join(', ');
+            const returnType = func.getReturnType().getText();
+            const node = {
+                id,
+                type: 'function',
+                position: { x: baseX, y: y },
+                data: {
+                    functionName: name,
+                    parameters: params,
+                    returnType: returnType,
+                    label: name,
+                    description: `Function in ${relativePath}`,
+                }
+            };
+            nodes.push(node);
+            nodeMap.set(id, node);
+            nodeMap.set(name, node);
+            count++;
+            y += 150;
+        }
+    }
+    return count;
+}
+function extractState(sourceFile, relativePath, gitHash, baseX, startY, nodes, nodeMap, usedIds, idCounters) {
+    let count = 0;
+    let y = startY;
+    sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((callExpr) => {
+        const expr = callExpr.getExpression();
+        if (expr.getText() === 'useState') {
+            const parent = callExpr.getParent();
+            if (Node.isVariableDeclaration(parent)) {
+                const nameNode = parent.getNameNode();
+                if (Node.isArrayBindingPattern(nameNode)) {
+                    const elements = nameNode.getElements();
+                    if (elements.length > 0) {
+                        const stateName = elements[0].getText();
+                        const id = getUniqueNodeId(relativePath, stateName, gitHash, usedIds, idCounters);
+                        const args = callExpr.getArguments();
+                        const initialValue = args.length > 0 ? args[0].getText() : 'undefined';
+                        const stateType = parent.getType().getText();
+                        const node = {
+                            id,
+                            type: 'state',
+                            position: { x: baseX, y: y },
+                            data: {
+                                stateName: stateName,
+                                stateType: stateType,
+                                initialValue: initialValue,
+                                label: stateName,
+                                description: `State in ${relativePath}`,
+                            }
+                        };
+                        nodes.push(node);
+                        nodeMap.set(id, node);
+                        nodeMap.set(stateName, node);
+                        count++;
+                        y += 150;
+                    }
+                }
+            }
+        }
+    });
+    return count;
+}
+function generateEdges(sourceFile, nodeMap, edges) {
+    // Find JSX elements (component usage)
+    sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach((jsxElement) => {
+        const openingElement = jsxElement.getOpeningElement();
+        const tagName = openingElement.getTagNameNode().getText();
+        const containingFunc = jsxElement.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration) ||
+            jsxElement.getFirstAncestorByKind(SyntaxKind.ArrowFunction);
+        if (containingFunc) {
+            const parentName = containingFunc.getName?.() ||
+                containingFunc.getParent()?.asKind(SyntaxKind.VariableDeclaration)?.getName() ||
+                null;
+            if (parentName && nodeMap.has(parentName) && nodeMap.has(tagName)) {
+                const sourceNode = nodeMap.get(parentName);
+                const targetNode = nodeMap.get(tagName);
+                if (sourceNode && targetNode) {
+                    const edgeId = `e-${sourceNode.id}-${targetNode.id}`;
+                    if (!edges.find(e => e.id === edgeId)) {
+                        edges.push({
+                            id: edgeId,
+                            source: sourceNode.id,
+                            target: targetNode.id,
+                            type: 'floating',
+                        });
+                    }
+                }
+            }
+        }
+    });
+    // Find self-closing JSX elements
+    sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach((jsxElement) => {
+        const tagName = jsxElement.getTagNameNode().getText();
+        const containingFunc = jsxElement.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration) ||
+            jsxElement.getFirstAncestorByKind(SyntaxKind.ArrowFunction);
+        if (containingFunc) {
+            const parentName = containingFunc.getName?.() ||
+                containingFunc.getParent()?.asKind(SyntaxKind.VariableDeclaration)?.getName() ||
+                null;
+            if (parentName && nodeMap.has(parentName) && nodeMap.has(tagName)) {
+                const sourceNode = nodeMap.get(parentName);
+                const targetNode = nodeMap.get(tagName);
+                if (sourceNode && targetNode) {
+                    const edgeId = `e-${sourceNode.id}-${targetNode.id}`;
+                    if (!edges.find(e => e.id === edgeId)) {
+                        edges.push({
+                            id: edgeId,
+                            source: sourceNode.id,
+                            target: targetNode.id,
+                            type: 'floating',
+                        });
+                    }
+                }
+            }
+        }
+    });
+    // Find function calls
+    sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((callExpr) => {
+        const expr = callExpr.getExpression();
+        const calledName = expr.getText().split('.').pop();
+        if (calledName && nodeMap.has(calledName)) {
+            const containingFunc = callExpr.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration) ||
+                callExpr.getFirstAncestorByKind(SyntaxKind.ArrowFunction);
+            if (containingFunc) {
+                const parentName = containingFunc.getName?.() ||
+                    containingFunc.getParent()?.asKind(SyntaxKind.VariableDeclaration)?.getName() ||
+                    null;
+                if (parentName && nodeMap.has(parentName)) {
+                    const sourceNode = nodeMap.get(parentName);
+                    const targetNode = nodeMap.get(calledName);
+                    if (sourceNode && targetNode && sourceNode.id !== targetNode.id) {
+                        const edgeId = `e-${sourceNode.id}-${targetNode.id}`;
+                        if (!edges.find(e => e.id === edgeId)) {
+                            edges.push({
+                                id: edgeId,
+                                source: sourceNode.id,
+                                target: targetNode.id,
+                                type: 'floating',
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    });
+}

package/dist/git-utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Git Utilities
+ *
+ * Helper functions to interact with git repositories
+ */
+/**
+ * Get list of uncommitted changed files in a git repository
+ *
+ * @param {string} projectPath - Absolute path to project directory
+ * @returns {string[]} - Array of absolute file paths that have uncommitted changes
+ */
+export declare function getUncommittedChanges(projectPath: any): string[];
+/**
+ * Check if a directory is a git repository
+ *
+ * @param {string} projectPath - Absolute path to project directory
+ * @returns {boolean}
+ */
+export declare function isGitRepository(projectPath: any): boolean;
+/**
+ * Get list of untracked files in a git repository
+ *
+ * @param {string} projectPath - Absolute path to project directory
+ * @returns {string[]} - Array of absolute file paths that are untracked
+ */
+export declare function getUntrackedFiles(projectPath: any): string[];
+/**
+ * Get all files with changes (committed or not)
+ *
+ * @param {string} projectPath - Absolute path to project directory
+ * @returns {string[]} - Array of absolute file paths
+ */
+export declare function getAllChangedFiles(projectPath: any): string[];

package/dist/git-utils.js

@@ -0,0 +1,96 @@
+import { execSync } from 'child_process';
+import path from 'path';
+/**
+ * Git Utilities
+ *
+ * Helper functions to interact with git repositories
+ */
+/**
+ * Get list of uncommitted changed files in a git repository
+ *
+ * @param {string} projectPath - Absolute path to project directory
+ * @returns {string[]} - Array of absolute file paths that have uncommitted changes
+ */
+export function getUncommittedChanges(projectPath) {
+    try {
+        // Check if directory is a git repository
+        if (!isGitRepository(projectPath)) {
+            return [];
+        }
+        // Get modified, added, and deleted files (staged and unstaged)
+        const command = 'git diff --name-only HEAD && git diff --name-only --cached';
+        const output = execSync(command, {
+            cwd: projectPath,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore'], // Ignore stderr
+        });
+        // Parse output and convert to absolute paths
+        const files = output
+            .split('\n')
+            .filter(Boolean)
+            .map(file => path.resolve(projectPath, file.trim()));
+        // Remove duplicates
+        return [...new Set(files)];
+    }
+    catch (error) {
+        // If git command fails, return empty array
+        console.error('Failed to get git diff:', error.message);
+        return [];
+    }
+}
+/**
+ * Check if a directory is a git repository
+ *
+ * @param {string} projectPath - Absolute path to project directory
+ * @returns {boolean}
+ */
+export function isGitRepository(projectPath) {
+    try {
+        execSync('git rev-parse --is-inside-work-tree', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get list of untracked files in a git repository
+ *
+ * @param {string} projectPath - Absolute path to project directory
+ * @returns {string[]} - Array of absolute file paths that are untracked
+ */
+export function getUntrackedFiles(projectPath) {
+    try {
+        if (!isGitRepository(projectPath)) {
+            return [];
+        }
+        const output = execSync('git ls-files --others --exclude-standard', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        return output
+            .split('\n')
+            .filter(Boolean)
+            .map(file => path.resolve(projectPath, file.trim()));
+    }
+    catch (error) {
+        console.error('Failed to get untracked files:', error.message);
+        return [];
+    }
+}
+/**
+ * Get all files with changes (committed or not)
+ *
+ * @param {string} projectPath - Absolute path to project directory
+ * @returns {string[]} - Array of absolute file paths
+ */
+export function getAllChangedFiles(projectPath) {
+    const uncommitted = getUncommittedChanges(projectPath);
+    const untracked = getUntrackedFiles(projectPath);
+    return [...new Set([...uncommitted, ...untracked])];
+}

package/dist/incremental-analyzer.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Incremental Analyzer
+ *
+ * Performs incremental analysis by comparing new analysis results with
+ * previously stored results and generating a diff of changes.
+ */
+/**
+ * Perform incremental analysis on a project
+ *
+ * @param {string} projectId - Project identifier
+ * @param {string} projectPath - Absolute path to project
+ * @param {string[]} changedFiles - Optional array of changed file paths
+ * @returns {Object} - Incremental update with added, removed, and modified nodes/edges
+ */
+export declare function performIncrementalAnalysis(projectId: any, projectPath: any, changedFiles?: any[]): {
+    type: string;
+    analysis: Promise<{
+        project: {
+            id: string;
+            value: string;
+            title: string;
+            subtitle: string;
+            trend: number;
+            chartData: number[];
+            chartColor: string;
+        };
+        branches: {
+            id: string;
+            status: string;
+            name: string;
+            lastCommit: string;
+            lastCommitDate: string;
+            author: string;
+            commitCount: number;
+            pullRequests: number;
+        }[];
+        planData: Record<string, {
+            nodes: {
+                id: string;
+                type: "function" | "component" | "state" | "api" | "conditional" | "ternary" | "switch" | "try-catch" | "task";
+                position: {
+                    x: number;
+                    y: number;
+                };
+                data: {
+                    label: string;
+                    description?: string | undefined;
+                    componentName?: string | undefined;
+                    props?: string | undefined;
+                    functionName?: string | undefined;
+                    parameters?: string | undefined;
+                    returnType?: string | undefined;
+                    stateName?: string | undefined;
+                    stateType?: string | undefined;
+                    initialValue?: string | undefined;
+                    method?: string | undefined;
+                    endpoint?: string | undefined;
+                    responseType?: string | undefined;
+                    condition?: string | undefined;
+                    trueLabel?: string | undefined;
+                    falseLabel?: string | undefined;
+                    ternaryCondition?: string | undefined;
+                    ternaryTrue?: string | undefined;
+                    ternaryFalse?: string | undefined;
+                    trueValue?: string | undefined;
+                    falseValue?: string | undefined;
+                    switchExpression?: string | undefined;
+                    cases?: string | undefined;
+                    tryBlock?: string | undefined;
+                    catchBlock?: string | undefined;
+                };
+            }[];
+            edges: {
+                id: string;
+                type: string;
+                source: string;
+                target: string;
+                label?: string | undefined;
+                sourceHandle?: string | undefined;
+                targetHandle?: string | undefined;
+            }[];
+        }>;
+        analyzedAt: string;
+        logs?: string[] | undefined;
+    }>;
+    update: {
+        added: {
+            nodes: any[];
+            edges: any[];
+        };
+        removed: {
+            nodeIds: any[];
+            edgeIds: any[];
+        };
+        modified: {
+            nodes: any[];
+            edges: any[];
+        };
+    };
+};
+/**
+ * Generate diff between old and new analysis
+ *
+ * @param {Object} oldAnalysis - Previous analysis data
+ * @param {Object} newAnalysis - New analysis data
+ * @returns {Object} - Incremental update object
+ */
+export declare function generateDiff(oldAnalysis: any, newAnalysis: any): {
+    added: {
+        nodes: any[];
+        edges: any[];
+    };
+    removed: {
+        nodeIds: any[];
+        edgeIds: any[];
+    };
+    modified: {
+        nodes: any[];
+        edges: any[];
+    };
+};
+/**
+ * Check if an update has any changes
+ *
+ * @param {Object} update - Incremental update object
+ * @returns {boolean}
+ */
+export declare function hasChanges(update: any): boolean;