@diphyx/eslint-plugin 1.0.0

package/src/rules/radash-prefer-is.mjs

@@ -0,0 +1,51 @@
+// Prefer radash is* helpers over `typeof` comparisons.
+
+const TYPEOF_HELPERS = {
+    number: "isNumber",
+    string: "isString",
+    boolean: "isBoolean",
+    function: "isFunction",
+    symbol: "isSymbol",
+};
+
+// typeof x === "<type>" → the compared type string, or null.
+function getTypeofComparison(node) {
+    if (node.operator !== "===" && node.operator !== "!==") {
+        return null;
+    }
+
+    const typeofSide = [node.left, node.right].find(
+        (side) => side.type === "UnaryExpression" && side.operator === "typeof",
+    );
+    const literalSide = [node.left, node.right].find((side) => side.type === "Literal");
+
+    if (!typeofSide || !literalSide || typeof literalSide.value !== "string") {
+        return null;
+    }
+
+    return literalSide.value;
+}
+
+export default {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "prefer radash is* helpers over typeof comparisons",
+        },
+        messages: {
+            preferIs: "Use radash '{{helper}}()' instead of a 'typeof' comparison.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            BinaryExpression(node) {
+                const type = getTypeofComparison(node);
+                const helper = type && TYPEOF_HELPERS[type];
+                if (helper) {
+                    context.report({ node, messageId: "preferIs", data: { helper } });
+                }
+            },
+        };
+    },
+};

package/src/rules/radash-prefer-sleep.mjs

@@ -0,0 +1,53 @@
+// Prefer radash sleep() over wrapping setTimeout in a Promise.
+
+function isSetTimeoutCall(node) {
+    return (
+        Boolean(node) &&
+        node.type === "CallExpression" &&
+        node.callee.type === "Identifier" &&
+        node.callee.name === "setTimeout"
+    );
+}
+
+export default {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "prefer radash sleep() over wrapping setTimeout in a Promise",
+        },
+        messages: {
+            preferSleep: "Use radash 'sleep()' instead of wrapping setTimeout in a Promise.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            NewExpression(node) {
+                if (node.callee.type !== "Identifier" || node.callee.name !== "Promise") {
+                    return;
+                }
+
+                const executor = node.arguments[0];
+                if (
+                    !executor ||
+                    (executor.type !== "ArrowFunctionExpression" && executor.type !== "FunctionExpression")
+                ) {
+                    return;
+                }
+
+                const body = executor.body;
+                const wrapsSetTimeout =
+                    isSetTimeoutCall(body) ||
+                    (body.type === "BlockStatement" &&
+                        body.body.some(
+                            (statement) =>
+                                statement.type === "ExpressionStatement" && isSetTimeoutCall(statement.expression),
+                        ));
+
+                if (wrapsSetTimeout) {
+                    context.report({ node, messageId: "preferSleep" });
+                }
+            },
+        };
+    },
+};

package/src/rules/radash-prefer-sum.mjs

@@ -0,0 +1,71 @@
+// Prefer radash sum() over a reduce that adds values.
+
+// (a, b) => a + b  |  (a, b) => { return a + b }
+function isSumReducer(node) {
+    if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression") {
+        return false;
+    }
+
+    if (node.params.length < 2 || node.params[0].type !== "Identifier" || node.params[1].type !== "Identifier") {
+        return false;
+    }
+
+    let expression = node.body;
+    if (expression.type === "BlockStatement") {
+        if (expression.body.length !== 1 || expression.body[0].type !== "ReturnStatement") {
+            return false;
+        }
+
+        expression = expression.body[0].argument;
+    }
+
+    if (!expression || expression.type !== "BinaryExpression" || expression.operator !== "+") {
+        return false;
+    }
+
+    const names = new Set([node.params[0].name, node.params[1].name]);
+
+    return (
+        expression.left.type === "Identifier" &&
+        expression.right.type === "Identifier" &&
+        names.has(expression.left.name) &&
+        names.has(expression.right.name)
+    );
+}
+
+export default {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "prefer radash sum() over a reduce that adds values",
+        },
+        messages: {
+            preferSum: "Use radash 'sum()' instead of a reduce that adds values.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== "MemberExpression" || node.callee.computed) {
+                    return;
+                }
+
+                if (node.callee.property.type !== "Identifier" || node.callee.property.name !== "reduce") {
+                    return;
+                }
+
+                const [reducer, initial] = node.arguments;
+                if (!reducer || !isSumReducer(reducer)) {
+                    return;
+                }
+
+                if (initial && !(initial.type === "Literal" && initial.value === 0)) {
+                    return;
+                }
+
+                context.report({ node: node.callee.property, messageId: "preferSum" });
+            },
+        };
+    },
+};

package/src/rules/radash-prefer-unique.mjs

@@ -0,0 +1,30 @@
+// Prefer radash unique() over spreading a new Set.
+
+export default {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "prefer radash unique() over spreading a new Set",
+        },
+        messages: {
+            preferUnique: "Use radash 'unique()' instead of spreading a 'new Set(...)'.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            ArrayExpression(node) {
+                const only = node.elements.length === 1 ? node.elements[0] : null;
+                if (
+                    only &&
+                    only.type === "SpreadElement" &&
+                    only.argument.type === "NewExpression" &&
+                    only.argument.callee.type === "Identifier" &&
+                    only.argument.callee.name === "Set"
+                ) {
+                    context.report({ node, messageId: "preferUnique" });
+                }
+            },
+        };
+    },
+};

package/src/rules/script-define-object.mjs

@@ -0,0 +1,49 @@
+// Compiler macros must declare their shape with a runtime object argument, e.g.
+// defineProps({ ... }), rather than the type-only generic form defineProps<{ ... }>().
+// A type-only call has no runtime object, so it is reported; defineModel<T>({ ... })
+// (a type annotation plus the object) is fine because the object shape is present.
+
+import { isVueFile } from "../utils/vue.mjs";
+
+const MACROS = new Set(["defineProps", "defineModel", "defineEmits", "defineExpose"]);
+
+function hasObjectArgument(node) {
+    return node.arguments.some((argument) => argument.type === "ObjectExpression");
+}
+
+export default {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "define* macros must declare their shape with a runtime object, not the type-only form",
+        },
+        messages: {
+            requireObject:
+                "'{{macro}}' should declare its shape with a runtime object, e.g. {{macro}}({ ... }), not the type-only form.",
+        },
+        schema: [],
+    },
+    create(context) {
+        if (!isVueFile(context)) {
+            return {};
+        }
+
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== "Identifier" || !MACROS.has(node.callee.name)) {
+                    return;
+                }
+
+                if (!hasObjectArgument(node)) {
+                    context.report({
+                        node: node.callee,
+                        messageId: "requireObject",
+                        data: {
+                            macro: node.callee.name,
+                        },
+                    });
+                }
+            },
+        };
+    },
+};

package/src/rules/script-section-order.mjs

@@ -0,0 +1,159 @@
+// Enforce script-setup section order:
+// import → props → model → emit → composable → state → computed → watch → method
+// → lifecycle → expose.
+//
+// The compiler macros have a fixed order of their own: defineProps, then
+// defineModel, then defineEmits at the top, with defineExpose always last.
+
+import { getCallName } from "../utils/ast.mjs";
+import { isVueFile } from "../utils/vue.mjs";
+
+const ORDER = [
+    "import",
+    "props",
+    "model",
+    "emit",
+    "composable",
+    "state",
+    "computed",
+    "watch",
+    "method",
+    "lifecycle",
+    "expose",
+];
+
+const WATCH_CALLS = new Set(["watch", "watchEffect", "watchDebounced"]);
+
+const LIFECYCLE_CALLS = new Set(["onMounted", "onUnmounted", "onBeforeMount", "onBeforeUnmount", "onUpdated"]);
+
+const STATE_CALLS = new Set(["ref", "reactive", "shallowRef", "shallowReactive"]);
+
+// Compiler macros → their section. defineExpose is last; the rest sit at the top.
+const MACRO_SECTIONS = {
+    defineProps: "props",
+    defineModel: "model",
+    defineEmits: "emit",
+    defineExpose: "expose",
+};
+
+function classify(node) {
+    if (node.type === "ImportDeclaration") {
+        return "import";
+    }
+
+    if (node.type === "ExpressionStatement") {
+        const callName = getCallName(node.expression);
+
+        if (callName && MACRO_SECTIONS[callName]) {
+            return MACRO_SECTIONS[callName];
+        }
+
+        if (callName && WATCH_CALLS.has(callName)) {
+            return "watch";
+        }
+
+        if (callName && LIFECYCLE_CALLS.has(callName)) {
+            return "lifecycle";
+        }
+
+        return null;
+    }
+
+    if (node.type === "VariableDeclaration") {
+        for (const declarator of node.declarations) {
+            if (!declarator.init) {
+                continue;
+            }
+
+            // const handler = () => {} | function () {}
+            if (declarator.init.type === "ArrowFunctionExpression" || declarator.init.type === "FunctionExpression") {
+                return "method";
+            }
+
+            const callName = getCallName(declarator.init);
+            if (!callName) {
+                continue;
+            }
+
+            if (MACRO_SECTIONS[callName]) {
+                return MACRO_SECTIONS[callName];
+            }
+
+            if (/^use[A-Z]/.test(callName)) {
+                return "composable";
+            }
+
+            // Empty refs (e.g. `const el = ref()`) are template refs — they must sit next
+            // to the composable that consumes them, so they are exempt from state ordering.
+            if (STATE_CALLS.has(callName) && declarator.init.arguments.length > 0) {
+                return "state";
+            }
+
+            if (callName === "computed") {
+                return "computed";
+            }
+
+            if (WATCH_CALLS.has(callName)) {
+                return "watch";
+            }
+
+            if (LIFECYCLE_CALLS.has(callName)) {
+                return "lifecycle";
+            }
+        }
+
+        return null;
+    }
+
+    if (node.type === "FunctionDeclaration") {
+        return "method";
+    }
+
+    return null;
+}
+
+export default {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description:
+                "enforce script setup section order (import → props → model → emit → composable → state → computed → watch → method → lifecycle → expose)",
+        },
+        messages: {
+            outOfOrder: "'{{current}}' section should come after '{{previous}}' section, not before.",
+        },
+        schema: [],
+    },
+    create(context) {
+        if (!isVueFile(context)) {
+            return {};
+        }
+
+        let lastSeenIndex = -1;
+        let lastSeenCategory = null;
+
+        return {
+            "Program > *"(node) {
+                const category = classify(node);
+                if (!category) {
+                    return;
+                }
+
+                const categoryIndex = ORDER.indexOf(category);
+                if (categoryIndex < lastSeenIndex) {
+                    context.report({
+                        node,
+                        messageId: "outOfOrder",
+                        data: {
+                            current: category,
+                            previous: lastSeenCategory,
+                        },
+                    });
+                } else if (categoryIndex > lastSeenIndex) {
+                    lastSeenIndex = categoryIndex;
+                    lastSeenCategory = category;
+                }
+            },
+        };
+    },
+};

package/src/rules/store-config-order.mjs

@@ -0,0 +1,55 @@
+// createStore config keys must follow name → model → view → action → compose → lazy.
+
+import { SECTION_ORDER, getCreateStoreConfig, getKeyedProperties, isCreateStoreCall } from "../utils/store.mjs";
+
+export default {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "createStore config keys must follow name → model → view → action → compose → lazy",
+        },
+        messages: {
+            outOfOrder: "createStore '{{current}}' should come before '{{previous}}'.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!isCreateStoreCall(node)) {
+                    return;
+                }
+
+                const config = getCreateStoreConfig(node);
+                if (!config) {
+                    return;
+                }
+
+                let lastIndex = -1;
+                let lastKey = null;
+
+                for (const property of getKeyedProperties(config)) {
+                    const index = SECTION_ORDER.indexOf(property.key.name);
+                    if (index === -1) {
+                        // Unknown keys are handled by store-no-unknown-key.
+                        continue;
+                    }
+
+                    if (index < lastIndex) {
+                        context.report({
+                            node: property,
+                            messageId: "outOfOrder",
+                            data: {
+                                current: property.key.name,
+                                previous: lastKey,
+                            },
+                        });
+                    } else {
+                        lastIndex = index;
+                        lastKey = property.key.name;
+                    }
+                }
+            },
+        };
+    },
+};

package/src/rules/store-mode-enum.mjs

@@ -0,0 +1,41 @@
+// A commit-options object pairs `model` + `mode`; `mode` must use a ModelMode
+// enum (ModelManyMode.SET, ...) rather than a raw string literal.
+
+export default {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "store action 'mode' must use a ModelMode enum, not a string literal",
+        },
+        messages: {
+            useEnum: "Use a ModelManyMode/ModelOneMode enum for 'mode' instead of the string literal '{{value}}'.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            ObjectExpression(node) {
+                const properties = node.properties.filter(
+                    (property) => property.type === "Property" && property.key.type === "Identifier",
+                );
+
+                const modeProperty = properties.find((property) => property.key.name === "mode");
+                const hasModel = properties.some((property) => property.key.name === "model");
+                if (!modeProperty || !hasModel) {
+                    return;
+                }
+
+                const value = modeProperty.value;
+                if (value.type === "Literal" && typeof value.value === "string") {
+                    context.report({
+                        node: value,
+                        messageId: "useEnum",
+                        data: {
+                            value: value.value,
+                        },
+                    });
+                }
+            },
+        };
+    },
+};

package/src/rules/store-name-match.mjs

@@ -0,0 +1,56 @@
+// createStore `name` should match the store variable (accountStore → "account").
+
+import { findProperty, getCreateStoreConfig, isCreateStoreCall } from "../utils/store.mjs";
+
+export default {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "createStore name should match the store variable (accountStore → 'account')",
+        },
+        messages: {
+            mismatch: "createStore name '{{name}}' should match the store variable, expected '{{expected}}'.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!isCreateStoreCall(node)) {
+                    return;
+                }
+
+                const parent = node.parent;
+                if (!parent || parent.type !== "VariableDeclarator" || parent.id.type !== "Identifier") {
+                    return;
+                }
+
+                const config = getCreateStoreConfig(node);
+                if (!config) {
+                    return;
+                }
+
+                const nameProperty = findProperty(config, "name");
+                if (
+                    !nameProperty ||
+                    nameProperty.value.type !== "Literal" ||
+                    typeof nameProperty.value.value !== "string"
+                ) {
+                    return;
+                }
+
+                const expected = parent.id.name.replace(/Store$/, "");
+                if (nameProperty.value.value !== expected) {
+                    context.report({
+                        node: nameProperty.value,
+                        messageId: "mismatch",
+                        data: {
+                            name: nameProperty.value.value,
+                            expected,
+                        },
+                    });
+                }
+            },
+        };
+    },
+};

package/src/rules/store-no-unknown-key.mjs

@@ -0,0 +1,42 @@
+// createStore config must not contain unknown keys.
+
+import { ALLOWED_KEYS, getCreateStoreConfig, getKeyedProperties, isCreateStoreCall } from "../utils/store.mjs";
+
+export default {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "createStore config must not contain unknown keys",
+        },
+        messages: {
+            unknown: "Unknown createStore key '{{key}}'. Allowed: name, model, view, action, compose, lazy.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!isCreateStoreCall(node)) {
+                    return;
+                }
+
+                const config = getCreateStoreConfig(node);
+                if (!config) {
+                    return;
+                }
+
+                for (const property of getKeyedProperties(config)) {
+                    if (!ALLOWED_KEYS.has(property.key.name)) {
+                        context.report({
+                            node: property.key,
+                            messageId: "unknown",
+                            data: {
+                                key: property.key.name,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};

package/src/rules/store-require-action.mjs

@@ -0,0 +1,5 @@
+// createStore config must include an `action` section.
+
+import { requireKey } from "../utils/store.mjs";
+
+export default requireKey("action", "createStore is missing the 'action' section.");

package/src/rules/store-require-model.mjs

@@ -0,0 +1,5 @@
+// createStore config must include a `model` section.
+
+import { requireKey } from "../utils/store.mjs";
+
+export default requireKey("model", "createStore is missing the 'model' section.");

package/src/rules/store-require-name.mjs

@@ -0,0 +1,5 @@
+// createStore config must include a `name` property.
+
+import { requireKey } from "../utils/store.mjs";
+
+export default requireKey("name", "createStore is missing the required 'name' property.");

package/src/rules/store-require-view.mjs

@@ -0,0 +1,5 @@
+// createStore config must include a `view` section.
+
+import { requireKey } from "../utils/store.mjs";
+
+export default requireKey("view", "createStore is missing the 'view' section.");

package/src/rules/store-section-function.mjs

@@ -0,0 +1,47 @@
+// createStore model/view/action/compose sections must be factory functions.
+
+import { FUNCTION_SECTIONS, getCreateStoreConfig, getKeyedProperties, isCreateStoreCall } from "../utils/store.mjs";
+
+export default {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "createStore model/view/action/compose sections must be factory functions",
+        },
+        messages: {
+            notFunction: "createStore '{{section}}' must be a factory function, e.g. ({{section}}) => ({ ... }).",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!isCreateStoreCall(node)) {
+                    return;
+                }
+
+                const config = getCreateStoreConfig(node);
+                if (!config) {
+                    return;
+                }
+
+                for (const property of getKeyedProperties(config)) {
+                    if (!FUNCTION_SECTIONS.has(property.key.name)) {
+                        continue;
+                    }
+
+                    const value = property.value;
+                    if (value.type !== "ArrowFunctionExpression" && value.type !== "FunctionExpression") {
+                        context.report({
+                            node: property,
+                            messageId: "notFunction",
+                            data: {
+                                section: property.key.name,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};