eslint-plugin-builderbot 1.0.0

package/README.md

@@ -0,0 +1,11 @@
+# `eslint-plugin-bot-whatsapp-ts`
+
+> TODO: description
+
+## Usage
+
+```
+const eslintPluginBotWhatsappTs = require('eslint-plugin-bot-whatsapp-ts');
+
+// TODO: DEMONSTRATE API
+```

package/dist/configs/recommended.d.ts

@@ -0,0 +1,9 @@
+export declare const rulesRecommended: {
+    'bot-whatsapp/func-prefix-goto-flow-return': number;
+    'bot-whatsapp/func-prefix-end-flow-return': number;
+    'bot-whatsapp/func-prefix-dynamic-flow-await': number;
+    'bot-whatsapp/func-prefix-state-update-await': number;
+    'bot-whatsapp/func-prefix-fall-back-return': number;
+    'bot-whatsapp/func-prefix-endflow-flowdynamic': number;
+};
+//# sourceMappingURL=recommended.d.ts.map

package/dist/configs/recommended.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommended.d.ts","sourceRoot":"","sources":["../../src/configs/recommended.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB;;;;;;;CAO5B,CAAA"}

package/dist/index.cjs

@@ -0,0 +1,223 @@
+'use strict';
+
+const rulesRecommended = {
+    'bot-whatsapp/func-prefix-goto-flow-return': 2,
+    'bot-whatsapp/func-prefix-end-flow-return': 2,
+    'bot-whatsapp/func-prefix-dynamic-flow-await': 2,
+    'bot-whatsapp/func-prefix-state-update-await': 2,
+    'bot-whatsapp/func-prefix-fall-back-return': 2,
+    'bot-whatsapp/func-prefix-endflow-flowdynamic': 2,
+};
+
+function isInsideAddActionOrAddAnswer(node) {
+    let currentNode = node;
+    while (currentNode) {
+        if (currentNode.type === 'CallExpression' &&
+            currentNode.callee &&
+            currentNode.callee.property &&
+            (currentNode.callee.property.name === 'addAnswer' || currentNode.callee.property.name === 'addAction')) {
+            return true;
+        }
+        currentNode = currentNode.parent;
+    }
+    return false;
+}
+
+const processDynamicFlowAwait = (context) => {
+    return {
+        'CallExpression[callee.name="flowDynamic"]'(node) {
+            const parentNode = node.parent;
+            // Verificar si estamos dentro de un 'addAction' o 'addAnswer'
+            if (!isInsideAddActionOrAddAnswer(node)) {
+                return;
+            }
+            // Verificar si el nodo padre es 'AwaitExpression', de lo contrario se reporta
+            if (parentNode.type !== 'AwaitExpression') {
+                context.report({
+                    node,
+                    message: 'Please use "await" before "flowDynamic" function',
+                    fix: function (fixer) {
+                        return fixer.insertTextBefore(node, 'await ');
+                    },
+                });
+            }
+        },
+    };
+};
+
+const processEndFlowReturn = (context) => {
+    return {
+        'CallExpression[callee.name="endFlow"]'(node) {
+            const parentNode = node.parent;
+            // Verificar si estamos dentro de un 'addAction' o 'addAnswer'
+            if (!isInsideAddActionOrAddAnswer(node)) {
+                return;
+            }
+            // Verificar si nodo padre es de tipo ReturnStatement, si no lo es, reportar
+            if (parentNode.type !== 'ReturnStatement') {
+                context.report({
+                    node,
+                    message: 'Please ensure "endFlow" function is returned',
+                    fix: function (fixer) {
+                        return fixer.insertTextBefore(node, 'return ');
+                    },
+                });
+            }
+        },
+    };
+};
+
+const processFallBackReturn = (context) => {
+    return {
+        'CallExpression[callee.name="fallBack"]'(node) {
+            const parentNode = node.parent;
+            // Verificar si estamos dentro de un 'addAction' o 'addAnswer'
+            if (!isInsideAddActionOrAddAnswer(node)) {
+                return;
+            }
+            // Verificar si nodo padre es de tipo ReturnStatement, si no lo es, reportar
+            if (parentNode.type !== 'ReturnStatement') {
+                context.report({
+                    node,
+                    message: 'Please ensure "fallBack" function is returned',
+                    fix: function (fixer) {
+                        return fixer.insertTextBefore(node, 'return ');
+                    },
+                });
+            }
+        },
+    };
+};
+
+const processGotoFlowReturn = (context) => {
+    return {
+        'CallExpression[callee.name="gotoFlow"]'(node) {
+            const parentNode = node.parent;
+            // Verificar si estamos dentro de un 'addAction' o 'addAnswer'
+            if (!isInsideAddActionOrAddAnswer(node)) {
+                return;
+            }
+            // Verificar si nodo padre es de tipo ReturnStatement, si no lo es, reportar
+            if (parentNode.type !== 'ReturnStatement') {
+                context.report({
+                    node,
+                    message: 'Please ensure "gotoFlow" function is returned',
+                    fix: function (fixer) {
+                        return fixer.insertTextBefore(node, 'return ');
+                    },
+                });
+            }
+        },
+    };
+};
+
+const processStateUpdateAwait = (context) => {
+    return {
+        'MemberExpression[property.name="update"]'(node) {
+            // Verificar si el objeto es 'state'
+            if (node.object.name !== 'state') {
+                return;
+            }
+            if (node.object.name === 'state') {
+                const sourceCode = context.getSourceCode();
+                const rangeStart = node.range[0] - 6; // Longitud de "await "
+                const rangeEnd = node.range[0];
+                const parentNodeText = sourceCode.getText().substring(rangeStart, rangeEnd);
+                if (parentNodeText.includes('await')) {
+                    return;
+                }
+            }
+            const parentNode = node.parent;
+            // Verificar si estamos dentro de un 'addAction' o 'addAnswer'
+            if (!isInsideAddActionOrAddAnswer(node)) {
+                return;
+            }
+            // Verificar si el nodo padre es 'AwaitExpression', de lo contrario se reporta
+            if (parentNode.type !== 'AwaitExpression') {
+                context.report({
+                    node,
+                    message: 'Please use "await" before "state.update"',
+                    fix: function (fixer) {
+                        // Comprueba si existe un await antes de state.update
+                        const sourceCode = context.getSourceCode();
+                        const rangeStart = node.range[0] - 7; // Longitud de "await "
+                        const rangeEnd = node.range[0];
+                        const parentNodeText = sourceCode.getText().substring(rangeStart, rangeEnd);
+                        if (parentNodeText.trim() !== 'await') {
+                            return fixer.insertTextBefore(node, 'await ');
+                        }
+                    },
+                });
+            }
+        },
+    };
+};
+
+const processEndFlowWithFlowDynamic = (context) => {
+    return {
+        'CallExpression[callee.name="endFlow"]'(node) {
+            if (!isInsideAddActionOrAddAnswer(node)) {
+                return;
+            }
+            const blockStatement = context
+                .getAncestors()
+                .find((ancestor) => ancestor.type === 'BlockStatement');
+            if (blockStatement) {
+                const calleInsideCtx = blockStatement.body.map((j) => j?.expression?.argument?.callee?.name);
+                if (calleInsideCtx.includes('flowDynamic')) {
+                    context.report({
+                        node,
+                        message: 'Do not use endFlow in the same execution context as flowDynamic.',
+                    });
+                }
+            }
+        },
+    };
+};
+
+const configs = {
+    recommended: {
+        rules: rulesRecommended,
+    },
+};
+const rules = {
+    'func-prefix-goto-flow-return': {
+        meta: {
+            fixable: 'code',
+        },
+        create: processGotoFlowReturn,
+    },
+    'func-prefix-fall-back-return': {
+        meta: {
+            fixable: 'code',
+        },
+        create: processFallBackReturn,
+    },
+    'func-prefix-end-flow-return': {
+        meta: {
+            fixable: 'code',
+        },
+        create: processEndFlowReturn,
+    },
+    'func-prefix-dynamic-flow-await': {
+        meta: {
+            fixable: 'code',
+        },
+        create: processDynamicFlowAwait,
+    },
+    'func-prefix-state-update-await': {
+        meta: {
+            fixable: 'code',
+        },
+        create: processStateUpdateAwait,
+    },
+    'func-prefix-endflow-flowdynamic': {
+        meta: {
+            fixable: 'code',
+        },
+        create: processEndFlowWithFlowDynamic,
+    },
+};
+
+exports.configs = configs;
+exports.rules = rules;

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+declare const configs: {
+    recommended: {
+        rules: {
+            'bot-whatsapp/func-prefix-goto-flow-return': number;
+            'bot-whatsapp/func-prefix-end-flow-return': number;
+            'bot-whatsapp/func-prefix-dynamic-flow-await': number;
+            'bot-whatsapp/func-prefix-state-update-await': number;
+            'bot-whatsapp/func-prefix-fall-back-return': number;
+            'bot-whatsapp/func-prefix-endflow-flowdynamic': number;
+        };
+    };
+};
+declare const rules: {
+    'func-prefix-goto-flow-return': {
+        meta: {
+            fixable: string;
+        };
+        create: (context: import("./types").Context) => {
+            'CallExpression[callee.name="gotoFlow"]'(node: import("./types").INode): void;
+        };
+    };
+    'func-prefix-fall-back-return': {
+        meta: {
+            fixable: string;
+        };
+        create: (context: import("./types").Context) => {
+            'CallExpression[callee.name="fallBack"]'(node: import("./types").INode): void;
+        };
+    };
+    'func-prefix-end-flow-return': {
+        meta: {
+            fixable: string;
+        };
+        create: (context: import("./types").Context) => {
+            'CallExpression[callee.name="endFlow"]'(node: import("./types").INode): void;
+        };
+    };
+    'func-prefix-dynamic-flow-await': {
+        meta: {
+            fixable: string;
+        };
+        create: (context: import("./types").Context) => {
+            'CallExpression[callee.name="flowDynamic"]'(node: import("./types").INode): void;
+        };
+    };
+    'func-prefix-state-update-await': {
+        meta: {
+            fixable: string;
+        };
+        create: (context: any) => {
+            'MemberExpression[property.name="update"]'(node: any): void;
+        };
+    };
+    'func-prefix-endflow-flowdynamic': {
+        meta: {
+            fixable: string;
+        };
+        create: (context: import("./types").Context) => {
+            'CallExpression[callee.name="endFlow"]'(node: import("./types").INode): void;
+        };
+    };
+};
+export { rules, configs };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,QAAA,MAAM,OAAO;;;;;;;;;;;CAIZ,CAAA;AACD,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCV,CAAA;AAED,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAA"}

package/dist/rules/index.d.ts

@@ -0,0 +1,7 @@
+export { processDynamicFlowAwait } from './processDynamicFlowAwait';
+export { processEndFlowReturn } from './processEndFlowReturn';
+export { processFallBackReturn } from './processFallBackReturn';
+export { processGotoFlowReturn } from './processGotoFlowReturn';
+export { processStateUpdateAwait } from './processStateUpdateAwait';
+export { processEndFlowWithFlowDynamic } from './processEndFlowWithFlowDynamic';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAA;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAA;AACnE,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAA"}

package/dist/rules/processDynamicFlowAwait.d.ts

@@ -0,0 +1,6 @@
+import { Context, INode } from '../types';
+declare const processDynamicFlowAwait: (context: Context) => {
+    'CallExpression[callee.name="flowDynamic"]'(node: INode): void;
+};
+export { processDynamicFlowAwait };
+//# sourceMappingURL=processDynamicFlowAwait.d.ts.map

package/dist/rules/processDynamicFlowAwait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processDynamicFlowAwait.d.ts","sourceRoot":"","sources":["../../src/rules/processDynamicFlowAwait.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAGzC,QAAA,MAAM,uBAAuB,YAAa,OAAO;sDAES,KAAK;CAoB9D,CAAA;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA"}

package/dist/rules/processEndFlowReturn.d.ts

@@ -0,0 +1,6 @@
+import { INode, Context } from '../types';
+declare const processEndFlowReturn: (context: Context) => {
+    'CallExpression[callee.name="endFlow"]'(node: INode): void;
+};
+export { processEndFlowReturn };
+//# sourceMappingURL=processEndFlowReturn.d.ts.map

package/dist/rules/processEndFlowReturn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processEndFlowReturn.d.ts","sourceRoot":"","sources":["../../src/rules/processEndFlowReturn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAGzC,QAAA,MAAM,oBAAoB,YAAa,OAAO;kDAEQ,KAAK;CAoB1D,CAAA;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAA"}

package/dist/rules/processEndFlowWithFlowDynamic.d.ts

@@ -0,0 +1,6 @@
+import { INode, Context } from '../types';
+declare const processEndFlowWithFlowDynamic: (context: Context) => {
+    'CallExpression[callee.name="endFlow"]'(node: INode): void;
+};
+export { processEndFlowWithFlowDynamic };
+//# sourceMappingURL=processEndFlowWithFlowDynamic.d.ts.map

package/dist/rules/processEndFlowWithFlowDynamic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processEndFlowWithFlowDynamic.d.ts","sourceRoot":"","sources":["../../src/rules/processEndFlowWithFlowDynamic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAGzC,QAAA,MAAM,6BAA6B,YAAa,OAAO;kDAED,KAAK;CAsB1D,CAAA;AAED,OAAO,EAAE,6BAA6B,EAAE,CAAA"}

package/dist/rules/processFallBackReturn.d.ts

@@ -0,0 +1,6 @@
+import { INode, Context } from '../types';
+declare const processFallBackReturn: (context: Context) => {
+    'CallExpression[callee.name="fallBack"]'(node: INode): void;
+};
+export { processFallBackReturn };
+//# sourceMappingURL=processFallBackReturn.d.ts.map

package/dist/rules/processFallBackReturn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processFallBackReturn.d.ts","sourceRoot":"","sources":["../../src/rules/processFallBackReturn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAGzC,QAAA,MAAM,qBAAqB,YAAa,OAAO;mDAEQ,KAAK;CAoB3D,CAAA;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAA"}

package/dist/rules/processGotoFlowReturn.d.ts

@@ -0,0 +1,6 @@
+import { INode, Context } from '../types';
+declare const processGotoFlowReturn: (context: Context) => {
+    'CallExpression[callee.name="gotoFlow"]'(node: INode): void;
+};
+export { processGotoFlowReturn };
+//# sourceMappingURL=processGotoFlowReturn.d.ts.map

package/dist/rules/processGotoFlowReturn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processGotoFlowReturn.d.ts","sourceRoot":"","sources":["../../src/rules/processGotoFlowReturn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAGzC,QAAA,MAAM,qBAAqB,YAAa,OAAO;mDAEQ,KAAK;CAoB3D,CAAA;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAA"}

package/dist/rules/processStateUpdateAwait.d.ts

@@ -0,0 +1,5 @@
+declare const processStateUpdateAwait: (context: any) => {
+    'MemberExpression[property.name="update"]'(node: any): void;
+};
+export { processStateUpdateAwait };
+//# sourceMappingURL=processStateUpdateAwait.d.ts.map

package/dist/rules/processStateUpdateAwait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processStateUpdateAwait.d.ts","sourceRoot":"","sources":["../../src/rules/processStateUpdateAwait.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,uBAAuB,YAAa,GAAG;qDAEY,GAAG;CAyC3D,CAAA;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA"}

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+export interface INode {
+    type: string;
+    callee?: {
+        name: string;
+        property?: {
+            name?: string;
+        };
+    };
+    arguments?: any;
+    parent?: Parent;
+}
+export interface Parent {
+    arguments: any;
+    type: string;
+    callee?: {
+        property?: {
+            name?: string;
+        };
+    };
+}
+export interface ReportOptions {
+    node: INode;
+    message: string;
+    fix?: (fixer: any) => void;
+}
+export interface Context {
+    getAncestors?: () => any;
+    report: (options: ReportOptions) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,KAAK;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE;QACL,IAAI,EAAE,MAAM,CAAA;QACZ,QAAQ,CAAC,EAAE;YACP,IAAI,CAAC,EAAE,MAAM,CAAA;SAChB,CAAA;KACJ,CAAA;IACD,SAAS,CAAC,EAAE,GAAG,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,MAAM;IACnB,SAAS,EAAE,GAAG,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE;YACP,IAAI,CAAC,EAAE,MAAM,CAAA;SAChB,CAAA;KACJ,CAAA;CACJ;AAED,MAAM,WAAW,aAAa;IAC1B,IAAI,EAAE,KAAK,CAAA;IACX,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;CAC7B;AAED,MAAM,WAAW,OAAO;IACpB,YAAY,CAAC,EAAE,MAAM,GAAG,CAAA;IACxB,MAAM,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,CAAA;CAC3C"}

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './isInsideAddActionOrAddAnswer';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAA"}

package/dist/utils/isInsideAddActionOrAddAnswer.d.ts

@@ -0,0 +1,4 @@
+import { INode } from '../types';
+declare function isInsideAddActionOrAddAnswer(node: INode): boolean;
+export { isInsideAddActionOrAddAnswer };
+//# sourceMappingURL=isInsideAddActionOrAddAnswer.d.ts.map

package/dist/utils/isInsideAddActionOrAddAnswer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isInsideAddActionOrAddAnswer.d.ts","sourceRoot":"","sources":["../../src/utils/isInsideAddActionOrAddAnswer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAEhC,iBAAS,4BAA4B,CAAC,IAAI,EAAE,KAAK,WAchD;AAED,OAAO,EAAE,4BAA4B,EAAE,CAAA"}

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "eslint-plugin-builderbot",
+    "version": "1.0.0",
+    "description": "> TODO: description",
+    "author": "vicente1992 <vic_ortiz20@hotmail.es>",
+    "homepage": "https://github.com/vicente1992/bot-whatsapp#readme",
+    "license": "ISC",
+    "main": "dist/index.cjs",
+    "types": "dist/index.d.ts",
+    "type": "module",
+    "directories": {
+        "src": "src",
+        "test": "__tests__"
+    },
+    "files": [
+        "./dist/"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/vicente1992/bot-whatsapp.git"
+    },
+    "scripts": {
+        "build": "rimraf dist && rollup --config",
+        "test": " npx uvu -r tsm ./__tests__ .test.ts",
+        "test:coverage": "npx c8 npm run test",
+        "test:debug": " npx tsm --inspect-brk ../../node_modules/uvu/bin.js ./__tests__ .test.ts"
+    },
+    "bugs": {
+        "url": "https://github.com/vicente1992/bot-whatsapp/issues"
+    },
+    "devDependencies": {
+        "@rollup/plugin-commonjs": "^25.0.7",
+        "@rollup/plugin-node-resolve": "^15.2.3",
+        "@rollup/plugin-terser": "^0.4.4",
+        "@types/eslint": "^8.56.2",
+        "@types/node": "^20.11.0",
+        "@types/sinon": "^17.0.3",
+        "kleur": "^4.1.5",
+        "rimraf": "^3.0.2",
+        "rollup-plugin-typescript2": "^0.36.0",
+        "sinon": "^17.0.1",
+        "tslib": "^2.6.2",
+        "tsm": "^2.3.0"
+    },
+    "gitHead": "f21e49621dffad2a1226aecea535668016f07b14"
+}