cmp-standards 2.0.0

package/dist/eslint/index.d.ts

@@ -0,0 +1,161 @@
+/**
+ * ESLint Plugin: cmp-standards
+ *
+ * Universal and configurable ESLint rules for MetaNautical projects.
+ * Rules are organized into categories:
+ *
+ * UNIVERSAL - Apply to all projects (security, performance, React best practices)
+ * CONFIGURABLE - Adapt based on project.config.json
+ * PROJECT-SPECIFIC - Only for projects that explicitly enable them
+ *
+ * @see https://github.com/carlosmartinpavon/carlosmartinpavon
+ */
+export declare const rules: {
+    'no-raw-sql': import("eslint").Rule.RuleModule;
+    'require-zod-validation': import("eslint").Rule.RuleModule;
+    'no-await-in-loop': import("eslint").Rule.RuleModule;
+    'semantic-tokens-only': import("eslint").Rule.RuleModule;
+    'no-async-useeffect': import("eslint").Rule.RuleModule;
+    'no-inline-functions-in-jsx': import("eslint").Rule.RuleModule;
+    'no-sequential-api-calls': import("eslint").Rule.RuleModule;
+    'require-loading-states': import("eslint").Rule.RuleModule;
+    'consistent-error-handling': import("eslint").Rule.RuleModule;
+    'finance-ledger-sync': import("eslint").Rule.RuleModule;
+    'prefer-server-components': import("eslint").Rule.RuleModule;
+};
+export declare const configs: {
+    /**
+     * Recommended config - universal rules only
+     */
+    recommended: {
+        plugins: string[];
+        rules: {
+            'cmp/no-raw-sql': string;
+            'cmp/require-zod-validation': string;
+            'cmp/no-await-in-loop': string;
+            'cmp/no-async-useeffect': string;
+            'cmp/no-inline-functions-in-jsx': string;
+            'cmp/no-sequential-api-calls': string;
+            'cmp/require-loading-states': string;
+            'cmp/consistent-error-handling': string;
+        };
+    };
+    /**
+     * Strict config - all universal rules as errors
+     */
+    strict: {
+        plugins: string[];
+        rules: {
+            'cmp/no-raw-sql': string;
+            'cmp/require-zod-validation': string;
+            'cmp/no-await-in-loop': string;
+            'cmp/semantic-tokens-only': string;
+            'cmp/no-async-useeffect': string;
+            'cmp/no-inline-functions-in-jsx': string;
+            'cmp/no-sequential-api-calls': string;
+            'cmp/require-loading-states': string;
+            'cmp/consistent-error-handling': string;
+        };
+    };
+    /**
+     * Next.js config - includes Next.js specific rules
+     */
+    nextjs: {
+        plugins: string[];
+        rules: {
+            'cmp/no-raw-sql': string;
+            'cmp/require-zod-validation': string;
+            'cmp/prefer-server-components': string;
+            'cmp/no-async-useeffect': string;
+            'cmp/no-inline-functions-in-jsx': string;
+        };
+    };
+    /**
+     * Finance config - includes finance-specific rules
+     */
+    finance: {
+        plugins: string[];
+        rules: {
+            'cmp/no-raw-sql': string;
+            'cmp/require-zod-validation': string;
+            'cmp/finance-ledger-sync': string;
+        };
+    };
+};
+export { buildConfig, generateConfig, toFlatConfig, toLegacyConfig, printConfig, type ESLintConfig, type ConfigOptions, } from './config-builder.js';
+declare const _default: {
+    rules: {
+        'no-raw-sql': import("eslint").Rule.RuleModule;
+        'require-zod-validation': import("eslint").Rule.RuleModule;
+        'no-await-in-loop': import("eslint").Rule.RuleModule;
+        'semantic-tokens-only': import("eslint").Rule.RuleModule;
+        'no-async-useeffect': import("eslint").Rule.RuleModule;
+        'no-inline-functions-in-jsx': import("eslint").Rule.RuleModule;
+        'no-sequential-api-calls': import("eslint").Rule.RuleModule;
+        'require-loading-states': import("eslint").Rule.RuleModule;
+        'consistent-error-handling': import("eslint").Rule.RuleModule;
+        'finance-ledger-sync': import("eslint").Rule.RuleModule;
+        'prefer-server-components': import("eslint").Rule.RuleModule;
+    };
+    configs: {
+        /**
+         * Recommended config - universal rules only
+         */
+        recommended: {
+            plugins: string[];
+            rules: {
+                'cmp/no-raw-sql': string;
+                'cmp/require-zod-validation': string;
+                'cmp/no-await-in-loop': string;
+                'cmp/no-async-useeffect': string;
+                'cmp/no-inline-functions-in-jsx': string;
+                'cmp/no-sequential-api-calls': string;
+                'cmp/require-loading-states': string;
+                'cmp/consistent-error-handling': string;
+            };
+        };
+        /**
+         * Strict config - all universal rules as errors
+         */
+        strict: {
+            plugins: string[];
+            rules: {
+                'cmp/no-raw-sql': string;
+                'cmp/require-zod-validation': string;
+                'cmp/no-await-in-loop': string;
+                'cmp/semantic-tokens-only': string;
+                'cmp/no-async-useeffect': string;
+                'cmp/no-inline-functions-in-jsx': string;
+                'cmp/no-sequential-api-calls': string;
+                'cmp/require-loading-states': string;
+                'cmp/consistent-error-handling': string;
+            };
+        };
+        /**
+         * Next.js config - includes Next.js specific rules
+         */
+        nextjs: {
+            plugins: string[];
+            rules: {
+                'cmp/no-raw-sql': string;
+                'cmp/require-zod-validation': string;
+                'cmp/prefer-server-components': string;
+                'cmp/no-async-useeffect': string;
+                'cmp/no-inline-functions-in-jsx': string;
+            };
+        };
+        /**
+         * Finance config - includes finance-specific rules
+         */
+        finance: {
+            plugins: string[];
+            rules: {
+                'cmp/no-raw-sql': string;
+                'cmp/require-zod-validation': string;
+                'cmp/finance-ledger-sync': string;
+            };
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/eslint/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/eslint/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAiBH,eAAO,MAAM,KAAK;;;;;;;;;;;;CAejB,CAAA;AAED,eAAO,MAAM,OAAO;IAClB;;OAEG;;;;;;;;;;;;;;IAeH;;OAEG;;;;;;;;;;;;;;;IAgBH;;OAEG;;;;;;;;;;;IAYH;;OAEG;;;;;;;;;CASJ,CAAA;AAGD,OAAO,EACL,WAAW,EACX,cAAc,EACd,YAAY,EACZ,cAAc,EACd,WAAW,EACX,KAAK,YAAY,EACjB,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAA;;;;;;;;;;;;;;;;QAvE1B;;WAEG;;;;;;;;;;;;;;QAeH;;WAEG;;;;;;;;;;;;;;;QAgBH;;WAEG;;;;;;;;;;;QAYH;;WAEG;;;;;;;;;;;AAsBL,wBAGC"}

package/dist/eslint/index.js

@@ -0,0 +1,106 @@
+/**
+ * ESLint Plugin: cmp-standards
+ *
+ * Universal and configurable ESLint rules for MetaNautical projects.
+ * Rules are organized into categories:
+ *
+ * UNIVERSAL - Apply to all projects (security, performance, React best practices)
+ * CONFIGURABLE - Adapt based on project.config.json
+ * PROJECT-SPECIFIC - Only for projects that explicitly enable them
+ *
+ * @see https://github.com/carlosmartinpavon/carlosmartinpavon
+ */
+// Universal Rules (always apply)
+import noRawSql from './rules/no-raw-sql.js';
+import requireZodValidation from './rules/require-zod-validation.js';
+import noAwaitInLoop from './rules/no-await-in-loop.js';
+import semanticTokensOnly from './rules/semantic-tokens-only.js';
+import noAsyncUseeffect from './rules/no-async-useeffect.js';
+import noInlineFunctionsInJsx from './rules/no-inline-functions-in-jsx.js';
+import noSequentialApiCalls from './rules/no-sequential-api-calls.js';
+import requireLoadingStates from './rules/require-loading-states.js';
+import consistentErrorHandling from './rules/consistent-error-handling.js';
+// Configurable Rules (read from project config)
+import financeLedgerSync from './rules/finance-ledger-sync.js';
+import preferServerComponents from './rules/prefer-server-components.js';
+export const rules = {
+    // Universal
+    'no-raw-sql': noRawSql,
+    'require-zod-validation': requireZodValidation,
+    'no-await-in-loop': noAwaitInLoop,
+    'semantic-tokens-only': semanticTokensOnly,
+    'no-async-useeffect': noAsyncUseeffect,
+    'no-inline-functions-in-jsx': noInlineFunctionsInJsx,
+    'no-sequential-api-calls': noSequentialApiCalls,
+    'require-loading-states': requireLoadingStates,
+    'consistent-error-handling': consistentErrorHandling,
+    // Configurable
+    'finance-ledger-sync': financeLedgerSync,
+    'prefer-server-components': preferServerComponents,
+};
+export const configs = {
+    /**
+     * Recommended config - universal rules only
+     */
+    recommended: {
+        plugins: ['cmp'],
+        rules: {
+            'cmp/no-raw-sql': 'error',
+            'cmp/require-zod-validation': 'warn',
+            'cmp/no-await-in-loop': 'warn',
+            'cmp/no-async-useeffect': 'error',
+            'cmp/no-inline-functions-in-jsx': 'warn',
+            'cmp/no-sequential-api-calls': 'warn',
+            'cmp/require-loading-states': 'warn',
+            'cmp/consistent-error-handling': 'warn',
+        },
+    },
+    /**
+     * Strict config - all universal rules as errors
+     */
+    strict: {
+        plugins: ['cmp'],
+        rules: {
+            'cmp/no-raw-sql': 'error',
+            'cmp/require-zod-validation': 'error',
+            'cmp/no-await-in-loop': 'error',
+            'cmp/semantic-tokens-only': 'error',
+            'cmp/no-async-useeffect': 'error',
+            'cmp/no-inline-functions-in-jsx': 'error',
+            'cmp/no-sequential-api-calls': 'error',
+            'cmp/require-loading-states': 'error',
+            'cmp/consistent-error-handling': 'error',
+        },
+    },
+    /**
+     * Next.js config - includes Next.js specific rules
+     */
+    nextjs: {
+        plugins: ['cmp'],
+        rules: {
+            'cmp/no-raw-sql': 'error',
+            'cmp/require-zod-validation': 'warn',
+            'cmp/prefer-server-components': 'warn',
+            'cmp/no-async-useeffect': 'error',
+            'cmp/no-inline-functions-in-jsx': 'warn',
+        },
+    },
+    /**
+     * Finance config - includes finance-specific rules
+     */
+    finance: {
+        plugins: ['cmp'],
+        rules: {
+            'cmp/no-raw-sql': 'error',
+            'cmp/require-zod-validation': 'error',
+            'cmp/finance-ledger-sync': 'error',
+        },
+    },
+};
+// Config Builder
+export { buildConfig, generateConfig, toFlatConfig, toLegacyConfig, printConfig, } from './config-builder.js';
+export default {
+    rules,
+    configs,
+};
+//# sourceMappingURL=index.js.map

package/dist/eslint/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/eslint/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,iCAAiC;AACjC,OAAO,QAAQ,MAAM,uBAAuB,CAAA;AAC5C,OAAO,oBAAoB,MAAM,mCAAmC,CAAA;AACpE,OAAO,aAAa,MAAM,6BAA6B,CAAA;AACvD,OAAO,kBAAkB,MAAM,iCAAiC,CAAA;AAChE,OAAO,gBAAgB,MAAM,+BAA+B,CAAA;AAC5D,OAAO,sBAAsB,MAAM,uCAAuC,CAAA;AAC1E,OAAO,oBAAoB,MAAM,oCAAoC,CAAA;AACrE,OAAO,oBAAoB,MAAM,mCAAmC,CAAA;AACpE,OAAO,uBAAuB,MAAM,sCAAsC,CAAA;AAE1E,gDAAgD;AAChD,OAAO,iBAAiB,MAAM,gCAAgC,CAAA;AAC9D,OAAO,sBAAsB,MAAM,qCAAqC,CAAA;AAExE,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,YAAY;IACZ,YAAY,EAAE,QAAQ;IACtB,wBAAwB,EAAE,oBAAoB;IAC9C,kBAAkB,EAAE,aAAa;IACjC,sBAAsB,EAAE,kBAAkB;IAC1C,oBAAoB,EAAE,gBAAgB;IACtC,4BAA4B,EAAE,sBAAsB;IACpD,yBAAyB,EAAE,oBAAoB;IAC/C,wBAAwB,EAAE,oBAAoB;IAC9C,2BAA2B,EAAE,uBAAuB;IAEpD,eAAe;IACf,qBAAqB,EAAE,iBAAiB;IACxC,0BAA0B,EAAE,sBAAsB;CACnD,CAAA;AAED,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB;;OAEG;IACH,WAAW,EAAE;QACX,OAAO,EAAE,CAAC,KAAK,CAAC;QAChB,KAAK,EAAE;YACL,gBAAgB,EAAE,OAAO;YACzB,4BAA4B,EAAE,MAAM;YACpC,sBAAsB,EAAE,MAAM;YAC9B,wBAAwB,EAAE,OAAO;YACjC,gCAAgC,EAAE,MAAM;YACxC,6BAA6B,EAAE,MAAM;YACrC,4BAA4B,EAAE,MAAM;YACpC,+BAA+B,EAAE,MAAM;SACxC;KACF;IAED;;OAEG;IACH,MAAM,EAAE;QACN,OAAO,EAAE,CAAC,KAAK,CAAC;QAChB,KAAK,EAAE;YACL,gBAAgB,EAAE,OAAO;YACzB,4BAA4B,EAAE,OAAO;YACrC,sBAAsB,EAAE,OAAO;YAC/B,0BAA0B,EAAE,OAAO;YACnC,wBAAwB,EAAE,OAAO;YACjC,gCAAgC,EAAE,OAAO;YACzC,6BAA6B,EAAE,OAAO;YACtC,4BAA4B,EAAE,OAAO;YACrC,+BAA+B,EAAE,OAAO;SACzC;KACF;IAED;;OAEG;IACH,MAAM,EAAE;QACN,OAAO,EAAE,CAAC,KAAK,CAAC;QAChB,KAAK,EAAE;YACL,gBAAgB,EAAE,OAAO;YACzB,4BAA4B,EAAE,MAAM;YACpC,8BAA8B,EAAE,MAAM;YACtC,wBAAwB,EAAE,OAAO;YACjC,gCAAgC,EAAE,MAAM;SACzC;KACF;IAED;;OAEG;IACH,OAAO,EAAE;QACP,OAAO,EAAE,CAAC,KAAK,CAAC;QAChB,KAAK,EAAE;YACL,gBAAgB,EAAE,OAAO;YACzB,4BAA4B,EAAE,OAAO;YACrC,yBAAyB,EAAE,OAAO;SACnC;KACF;CACF,CAAA;AAED,iBAAiB;AACjB,OAAO,EACL,WAAW,EACX,cAAc,EACd,YAAY,EACZ,cAAc,EACd,WAAW,GAGZ,MAAM,qBAAqB,CAAA;AAE5B,eAAe;IACb,KAAK;IACL,OAAO;CACR,CAAA"}

package/dist/eslint/rules/consistent-error-handling.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ESLint Rule: cmp/consistent-error-handling
+ *
+ * Ensures consistent error handling patterns across the codebase.
+ */
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=consistent-error-handling.d.ts.map

package/dist/eslint/rules/consistent-error-handling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-error-handling.d.ts","sourceRoot":"","sources":["../../../src/eslint/rules/consistent-error-handling.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UAmDhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/dist/eslint/rules/consistent-error-handling.js

@@ -0,0 +1,52 @@
+/**
+ * ESLint Rule: cmp/consistent-error-handling
+ *
+ * Ensures consistent error handling patterns across the codebase.
+ */
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce consistent error handling patterns',
+            category: 'Best Practices',
+            recommended: true,
+        },
+        messages: {
+            emptyCatch: 'Empty catch block. Handle the error or re-throw it.',
+            consoleCatch: 'Use proper error handling instead of console.log in catch block.',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CatchClause(node) {
+                const body = node.body;
+                // Empty catch block
+                if (body.body.length === 0) {
+                    context.report({
+                        node,
+                        messageId: 'emptyCatch',
+                    });
+                    return;
+                }
+                // Only console.log/error in catch
+                if (body.body.length === 1) {
+                    const statement = body.body[0];
+                    if (statement.type === 'ExpressionStatement' &&
+                        statement.expression.type === 'CallExpression') {
+                        const callee = statement.expression.callee;
+                        if (callee.type === 'MemberExpression' &&
+                            callee.object?.name === 'console') {
+                            context.report({
+                                node,
+                                messageId: 'consoleCatch',
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+};
+export default rule;
+//# sourceMappingURL=consistent-error-handling.js.map

package/dist/eslint/rules/consistent-error-handling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-error-handling.js","sourceRoot":"","sources":["../../../src/eslint/rules/consistent-error-handling.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,IAAI,GAAoB;IAC5B,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EAAE,4CAA4C;YACzD,QAAQ,EAAE,gBAAgB;YAC1B,WAAW,EAAE,IAAI;SAClB;QACD,QAAQ,EAAE;YACR,UAAU,EAAE,qDAAqD;YACjE,YAAY,EAAE,kEAAkE;SACjF;QACD,MAAM,EAAE,EAAE;KACX;IAED,MAAM,CAAC,OAAO;QACZ,OAAO;YACL,WAAW,CAAC,IAAS;gBACnB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAA;gBAEtB,oBAAoB;gBACpB,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBAC3B,OAAO,CAAC,MAAM,CAAC;wBACb,IAAI;wBACJ,SAAS,EAAE,YAAY;qBACxB,CAAC,CAAA;oBACF,OAAM;gBACR,CAAC;gBAED,kCAAkC;gBAClC,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBAC3B,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;oBAC9B,IACE,SAAS,CAAC,IAAI,KAAK,qBAAqB;wBACxC,SAAS,CAAC,UAAU,CAAC,IAAI,KAAK,gBAAgB,EAC9C,CAAC;wBACD,MAAM,MAAM,GAAG,SAAS,CAAC,UAAU,CAAC,MAAM,CAAA;wBAC1C,IACE,MAAM,CAAC,IAAI,KAAK,kBAAkB;4BAClC,MAAM,CAAC,MAAM,EAAE,IAAI,KAAK,SAAS,EACjC,CAAC;4BACD,OAAO,CAAC,MAAM,CAAC;gCACb,IAAI;gCACJ,SAAS,EAAE,cAAc;6BAC1B,CAAC,CAAA;wBACJ,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;SACF,CAAA;IACH,CAAC;CACF,CAAA;AAED,eAAe,IAAI,CAAA"}

package/dist/eslint/rules/finance-ledger-sync.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ESLint Rule: cmp/finance-ledger-sync
+ *
+ * CRITICAL: Ensures finance operations call LedgerService.createEntry()
+ * This rule is configurable - only activates for projects with finance code.
+ *
+ * Every finance insert MUST have a corresponding ledger entry or cash flow breaks.
+ */
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=finance-ledger-sync.d.ts.map

package/dist/eslint/rules/finance-ledger-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finance-ledger-sync.d.ts","sourceRoot":"","sources":["../../../src/eslint/rules/finance-ledger-sync.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAUlC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8DhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/dist/eslint/rules/finance-ledger-sync.js

@@ -0,0 +1,72 @@
+/**
+ * ESLint Rule: cmp/finance-ledger-sync
+ *
+ * CRITICAL: Ensures finance operations call LedgerService.createEntry()
+ * This rule is configurable - only activates for projects with finance code.
+ *
+ * Every finance insert MUST have a corresponding ledger entry or cash flow breaks.
+ */
+const FINANCE_TABLES = [
+    'finance',
+    'expenses',
+    'payments',
+    'invoices',
+    'transactions',
+];
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure finance operations sync with LedgerService',
+            category: 'Finance',
+            recommended: false, // Only for projects with finance
+        },
+        messages: {
+            missingLedgerSync: 'Finance insert detected but no LedgerService.createEntry() call. Cash flow will be out of sync!',
+        },
+        schema: [],
+    },
+    create(context) {
+        let hasFinanceInsert = false;
+        let hasLedgerCall = false;
+        let financeInsertNode = null;
+        return {
+            'Program:exit'() {
+                if (hasFinanceInsert && !hasLedgerCall && financeInsertNode) {
+                    context.report({
+                        node: financeInsertNode,
+                        messageId: 'missingLedgerSync',
+                    });
+                }
+                hasFinanceInsert = false;
+                hasLedgerCall = false;
+                financeInsertNode = null;
+            },
+            CallExpression(node) {
+                const callee = node.callee;
+                // Check for insert into finance tables
+                if (callee.type === 'MemberExpression') {
+                    const methodName = callee.property?.name;
+                    // db.insert(financeTable)
+                    if (methodName === 'insert') {
+                        const arg = node.arguments[0];
+                        if (arg?.type === 'Identifier') {
+                            const tableName = arg.name.toLowerCase();
+                            if (FINANCE_TABLES.some(ft => tableName.includes(ft))) {
+                                hasFinanceInsert = true;
+                                financeInsertNode = node;
+                            }
+                        }
+                    }
+                    // LedgerService.createEntry()
+                    if (callee.object?.name === 'LedgerService' &&
+                        methodName === 'createEntry') {
+                        hasLedgerCall = true;
+                    }
+                }
+            },
+        };
+    },
+};
+export default rule;
+//# sourceMappingURL=finance-ledger-sync.js.map

package/dist/eslint/rules/finance-ledger-sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"finance-ledger-sync.js","sourceRoot":"","sources":["../../../src/eslint/rules/finance-ledger-sync.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,cAAc,GAAG;IACrB,SAAS;IACT,UAAU;IACV,UAAU;IACV,UAAU;IACV,cAAc;CACf,CAAA;AAED,MAAM,IAAI,GAAoB;IAC5B,IAAI,EAAE;QACJ,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACJ,WAAW,EAAE,mDAAmD;YAChE,QAAQ,EAAE,SAAS;YACnB,WAAW,EAAE,KAAK,EAAE,iCAAiC;SACtD;QACD,QAAQ,EAAE;YACR,iBAAiB,EAAE,iGAAiG;SACrH;QACD,MAAM,EAAE,EAAE;KACX;IAED,MAAM,CAAC,OAAO;QACZ,IAAI,gBAAgB,GAAG,KAAK,CAAA;QAC5B,IAAI,aAAa,GAAG,KAAK,CAAA;QACzB,IAAI,iBAAiB,GAAQ,IAAI,CAAA;QAEjC,OAAO;YACL,cAAc;gBACZ,IAAI,gBAAgB,IAAI,CAAC,aAAa,IAAI,iBAAiB,EAAE,CAAC;oBAC5D,OAAO,CAAC,MAAM,CAAC;wBACb,IAAI,EAAE,iBAAiB;wBACvB,SAAS,EAAE,mBAAmB;qBAC/B,CAAC,CAAA;gBACJ,CAAC;gBACD,gBAAgB,GAAG,KAAK,CAAA;gBACxB,aAAa,GAAG,KAAK,CAAA;gBACrB,iBAAiB,GAAG,IAAI,CAAA;YAC1B,CAAC;YAED,cAAc,CAAC,IAAS;gBACtB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAA;gBAE1B,uCAAuC;gBACvC,IAAI,MAAM,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;oBACvC,MAAM,UAAU,GAAG,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAA;oBAExC,0BAA0B;oBAC1B,IAAI,UAAU,KAAK,QAAQ,EAAE,CAAC;wBAC5B,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;wBAC7B,IAAI,GAAG,EAAE,IAAI,KAAK,YAAY,EAAE,CAAC;4BAC/B,MAAM,SAAS,GAAG,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAA;4BACxC,IAAI,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;gCACtD,gBAAgB,GAAG,IAAI,CAAA;gCACvB,iBAAiB,GAAG,IAAI,CAAA;4BAC1B,CAAC;wBACH,CAAC;oBACH,CAAC;oBAED,8BAA8B;oBAC9B,IACE,MAAM,CAAC,MAAM,EAAE,IAAI,KAAK,eAAe;wBACvC,UAAU,KAAK,aAAa,EAC5B,CAAC;wBACD,aAAa,GAAG,IAAI,CAAA;oBACtB,CAAC;gBACH,CAAC;YACH,CAAC;SACF,CAAA;IACH,CAAC;CACF,CAAA;AAED,eAAe,IAAI,CAAA"}

package/dist/eslint/rules/no-async-useeffect.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ESLint Rule: cmp/no-async-useeffect
+ *
+ * Prevents async functions directly in useEffect.
+ * Create an inner async function instead.
+ */
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=no-async-useeffect.d.ts.map

package/dist/eslint/rules/no-async-useeffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-async-useeffect.d.ts","sourceRoot":"","sources":["../../../src/eslint/rules/no-async-useeffect.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8ChB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/dist/eslint/rules/no-async-useeffect.js

@@ -0,0 +1,49 @@
+/**
+ * ESLint Rule: cmp/no-async-useeffect
+ *
+ * Prevents async functions directly in useEffect.
+ * Create an inner async function instead.
+ */
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent async useEffect callbacks',
+            category: 'Best Practices',
+            recommended: true,
+        },
+        messages: {
+            noAsyncUseEffect: 'useEffect callback cannot be async. Create an inner async function and call it.',
+            suggestion: `
+useEffect(() => {
+  const fetchData = async () => {
+    // your async code
+  };
+  fetchData();
+}, []);`,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === 'Identifier' &&
+                    node.callee.name === 'useEffect' &&
+                    node.arguments[0]) {
+                    const callback = node.arguments[0];
+                    // Check for async arrow function or async function expression
+                    if ((callback.type === 'ArrowFunctionExpression' ||
+                        callback.type === 'FunctionExpression') &&
+                        callback.async) {
+                        context.report({
+                            node: callback,
+                            messageId: 'noAsyncUseEffect',
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+export default rule;
+//# sourceMappingURL=no-async-useeffect.js.map

package/dist/eslint/rules/no-async-useeffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-async-useeffect.js","sourceRoot":"","sources":["../../../src/eslint/rules/no-async-useeffect.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,IAAI,GAAoB;IAC5B,IAAI,EAAE;QACJ,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACJ,WAAW,EAAE,mCAAmC;YAChD,QAAQ,EAAE,gBAAgB;YAC1B,WAAW,EAAE,IAAI;SAClB;QACD,QAAQ,EAAE;YACR,gBAAgB,EAAE,iFAAiF;YACnG,UAAU,EAAE;;;;;;QAMV;SACH;QACD,MAAM,EAAE,EAAE;KACX;IAED,MAAM,CAAC,OAAO;QACZ,OAAO;YACL,cAAc,CAAC,IAAS;gBACtB,IACE,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,YAAY;oBACjC,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,WAAW;oBAChC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EACjB,CAAC;oBACD,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;oBAElC,8DAA8D;oBAC9D,IACE,CAAC,QAAQ,CAAC,IAAI,KAAK,yBAAyB;wBAC3C,QAAQ,CAAC,IAAI,KAAK,oBAAoB,CAAC;wBACxC,QAAQ,CAAC,KAAK,EACd,CAAC;wBACD,OAAO,CAAC,MAAM,CAAC;4BACb,IAAI,EAAE,QAAQ;4BACd,SAAS,EAAE,kBAAkB;yBAC9B,CAAC,CAAA;oBACJ,CAAC;gBACH,CAAC;YACH,CAAC;SACF,CAAA;IACH,CAAC;CACF,CAAA;AAED,eAAe,IAAI,CAAA"}

package/dist/eslint/rules/no-await-in-loop.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ESLint Rule: cmp/no-await-in-loop
+ *
+ * Prevents await inside loops which causes sequential execution.
+ * Use Promise.all() for parallel execution instead.
+ */
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=no-await-in-loop.d.ts.map

package/dist/eslint/rules/no-await-in-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-await-in-loop.d.ts","sourceRoot":"","sources":["../../../src/eslint/rules/no-await-in-loop.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA+ChB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/dist/eslint/rules/no-await-in-loop.js

@@ -0,0 +1,51 @@
+/**
+ * ESLint Rule: cmp/no-await-in-loop
+ *
+ * Prevents await inside loops which causes sequential execution.
+ * Use Promise.all() for parallel execution instead.
+ */
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prevent await inside loops (use Promise.all instead)',
+            category: 'Performance',
+            recommended: true,
+        },
+        messages: {
+            awaitInLoop: 'Avoid await inside loops. Use Promise.all() for parallel execution.',
+        },
+        schema: [],
+    },
+    create(context) {
+        let loopDepth = 0;
+        function enterLoop() {
+            loopDepth++;
+        }
+        function exitLoop() {
+            loopDepth--;
+        }
+        return {
+            ForStatement: enterLoop,
+            'ForStatement:exit': exitLoop,
+            ForInStatement: enterLoop,
+            'ForInStatement:exit': exitLoop,
+            ForOfStatement: enterLoop,
+            'ForOfStatement:exit': exitLoop,
+            WhileStatement: enterLoop,
+            'WhileStatement:exit': exitLoop,
+            DoWhileStatement: enterLoop,
+            'DoWhileStatement:exit': exitLoop,
+            AwaitExpression(node) {
+                if (loopDepth > 0) {
+                    context.report({
+                        node,
+                        messageId: 'awaitInLoop',
+                    });
+                }
+            },
+        };
+    },
+};
+export default rule;
+//# sourceMappingURL=no-await-in-loop.js.map

package/dist/eslint/rules/no-await-in-loop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-await-in-loop.js","sourceRoot":"","sources":["../../../src/eslint/rules/no-await-in-loop.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,IAAI,GAAoB;IAC5B,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EAAE,sDAAsD;YACnE,QAAQ,EAAE,aAAa;YACvB,WAAW,EAAE,IAAI;SAClB;QACD,QAAQ,EAAE;YACR,WAAW,EAAE,qEAAqE;SACnF;QACD,MAAM,EAAE,EAAE;KACX;IAED,MAAM,CAAC,OAAO;QACZ,IAAI,SAAS,GAAG,CAAC,CAAA;QAEjB,SAAS,SAAS;YAChB,SAAS,EAAE,CAAA;QACb,CAAC;QAED,SAAS,QAAQ;YACf,SAAS,EAAE,CAAA;QACb,CAAC;QAED,OAAO;YACL,YAAY,EAAE,SAAS;YACvB,mBAAmB,EAAE,QAAQ;YAC7B,cAAc,EAAE,SAAS;YACzB,qBAAqB,EAAE,QAAQ;YAC/B,cAAc,EAAE,SAAS;YACzB,qBAAqB,EAAE,QAAQ;YAC/B,cAAc,EAAE,SAAS;YACzB,qBAAqB,EAAE,QAAQ;YAC/B,gBAAgB,EAAE,SAAS;YAC3B,uBAAuB,EAAE,QAAQ;YAEjC,eAAe,CAAC,IAAI;gBAClB,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;oBAClB,OAAO,CAAC,MAAM,CAAC;wBACb,IAAI;wBACJ,SAAS,EAAE,aAAa;qBACzB,CAAC,CAAA;gBACJ,CAAC;YACH,CAAC;SACF,CAAA;IACH,CAAC;CACF,CAAA;AAED,eAAe,IAAI,CAAA"}

package/dist/eslint/rules/no-inline-functions-in-jsx.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ESLint Rule: cmp/no-inline-functions-in-jsx
+ *
+ * Prevents inline function definitions in JSX props.
+ * These cause unnecessary re-renders.
+ */
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=no-inline-functions-in-jsx.d.ts.map

package/dist/eslint/rules/no-inline-functions-in-jsx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-inline-functions-in-jsx.d.ts","sourceRoot":"","sources":["../../../src/eslint/rules/no-inline-functions-in-jsx.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA2ChB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/dist/eslint/rules/no-inline-functions-in-jsx.js

@@ -0,0 +1,45 @@
+/**
+ * ESLint Rule: cmp/no-inline-functions-in-jsx
+ *
+ * Prevents inline function definitions in JSX props.
+ * These cause unnecessary re-renders.
+ */
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prevent inline functions in JSX props (causes re-renders)',
+            category: 'Performance',
+            recommended: true,
+        },
+        messages: {
+            noInlineFunction: 'Avoid inline functions in JSX. Extract to a const or use useCallback.',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            JSXAttribute(node) {
+                const value = node.value;
+                if (!value || value.type !== 'JSXExpressionContainer')
+                    return;
+                const expression = value.expression;
+                // Arrow functions or function expressions
+                if (expression.type === 'ArrowFunctionExpression' ||
+                    expression.type === 'FunctionExpression') {
+                    // Allow simple one-liners for event handlers
+                    const isSimple = expression.body.type !== 'BlockStatement' ||
+                        expression.body.body.length <= 1;
+                    if (!isSimple) {
+                        context.report({
+                            node: expression,
+                            messageId: 'noInlineFunction',
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+export default rule;
+//# sourceMappingURL=no-inline-functions-in-jsx.js.map

package/dist/eslint/rules/no-inline-functions-in-jsx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-inline-functions-in-jsx.js","sourceRoot":"","sources":["../../../src/eslint/rules/no-inline-functions-in-jsx.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,IAAI,GAAoB;IAC5B,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EAAE,2DAA2D;YACxE,QAAQ,EAAE,aAAa;YACvB,WAAW,EAAE,IAAI;SAClB;QACD,QAAQ,EAAE;YACR,gBAAgB,EAAE,uEAAuE;SAC1F;QACD,MAAM,EAAE,EAAE;KACX;IAED,MAAM,CAAC,OAAO;QACZ,OAAO;YACL,YAAY,CAAC,IAAS;gBACpB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAA;gBAExB,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,wBAAwB;oBAAE,OAAM;gBAE7D,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,CAAA;gBAEnC,0CAA0C;gBAC1C,IACE,UAAU,CAAC,IAAI,KAAK,yBAAyB;oBAC7C,UAAU,CAAC,IAAI,KAAK,oBAAoB,EACxC,CAAC;oBACD,6CAA6C;oBAC7C,MAAM,QAAQ,GACZ,UAAU,CAAC,IAAI,CAAC,IAAI,KAAK,gBAAgB;wBACzC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAA;oBAElC,IAAI,CAAC,QAAQ,EAAE,CAAC;wBACd,OAAO,CAAC,MAAM,CAAC;4BACb,IAAI,EAAE,UAAU;4BAChB,SAAS,EAAE,kBAAkB;yBAC9B,CAAC,CAAA;oBACJ,CAAC;gBACH,CAAC;YACH,CAAC;SACF,CAAA;IACH,CAAC;CACF,CAAA;AAED,eAAe,IAAI,CAAA"}