@shrpne/eslint-plugin-vue-extra 0.1.0

package/README.md

@@ -0,0 +1,148 @@
+# @shrpne/eslint-plugin-vue-extra
+
+ESLint rules for Vue + TypeScript that remove redundant/noise patterns around `defineProps` + `withDefaults`, where core/recommended Vue rules are mostly targeted non TypeScript-specific cases.
+
+## Install
+
+```bash
+npm i -D @shrpne/eslint-plugin-vue-extra @vue/eslint-config-typescript eslint-plugin-vue
+```
+
+## Quick Start (recommended preset)
+
+```js
+// eslint.config.mjs
+import pluginVue from 'eslint-plugin-vue';
+import { defineConfigWithVueTs, vueTsConfigs } from '@vue/eslint-config-typescript';
+import vueExtra from '@shrpne/eslint-plugin-vue-extra';
+
+export default defineConfigWithVueTs(
+    pluginVue.configs['flat/essential'],
+    vueTsConfigs.recommendedTypeChecked,
+    vueExtra.configs.recommended,
+);
+```
+
+The preset enables all rules from this plugin and disables `vue/require-default-prop` (it conflicts with `no-falsy-default-with-optional-prop`).
+
+## Rules
+
+- `no-falsy-default-with-optional-prop`: disallow configured falsy defaults for optional props.
+- `no-boolean-default-false`: disallow `false` defaults for boolean props.
+- `prefer-optional-boolean-prop`: prefer optional boolean props unless default is `true`.
+- `no-empty-defaults`: remove redundant `withDefaults(..., {})`.
+
+## Rule details
+
+### `no-falsy-default-with-optional-prop`
+
+In TypeScript, optional props stay typed with `| undefined`; defaults like `undefined` and `false` are usually noise.
+
+Options:
+
+```js
+['error', { disallow: ['undefined', 'false', 'null', `''`, '0'] }]
+```
+
+Default:
+
+```js
+['error', { disallow: ['undefined', 'false'] }]
+```
+
+```ts
+// before
+withDefaults(defineProps<{
+    label?: string;
+    isVisible?: boolean;
+}>(), {
+    label: undefined,
+    isVisible: false,
+});
+
+// after
+withDefaults(defineProps<{
+    label?: string;
+    isVisible?: boolean;
+}>(), {});
+```
+
+### `prefer-optional-boolean-prop`
+
+Required booleans without `default: true` are awkward in templates; optional booleans model presence/absence better.
+
+Options:
+
+```js
+['error', { fixReferencedTypes: true }]
+```
+
+By default, fixer only updates inline `defineProps<{ ... }>()`.  
+With `fixReferencedTypes: true`, it can also fix same-file referenced types (`defineProps<Props>()`).
+
+```ts
+// before
+withDefaults(defineProps<{ enabled: boolean }>(), {});
+
+// after
+withDefaults(defineProps<{ enabled?: boolean }>(), {});
+```
+
+### `no-boolean-default-false`
+
+This rule focuses on reducing noise by removing redundant `false` defaults. It's related to `vue/no-boolean-default`, but serves a different goal, `vue/no-boolean-default` focuses on HTML-compatibility disallowing `default: true` behavior, while this rule does nothing for `default: true` cases. So `"vue/no-boolean-default": ["error", "default-false"]` acts opposite to this rule.
+
+When not to use:
+
+Generally `vue/no-boolean-default: "error"` is recommended to remove all boolean defaults. But if you want to keep `default: true` cases, this rule will help remove `false` defaults.
+
+Also, if you use `vueExtra.configs.recommended` preset, this case will be already covered:
+- `prefer-optional-boolean-prop` - makes boolean prop optional
+- `no-falsy-default-with-optional-prop` - removes falsy defaults for this optional prop
+
+
+Options: none.
+
+Fixer: removes the `false` entry from `withDefaults(...)`.
+
+```ts
+// before
+withDefaults(defineProps<{
+    enabled?: boolean;
+    showLabel?: boolean;
+}>(), {
+    enabled: false,
+    showLabel: true,
+});
+
+// after
+withDefaults(defineProps<{
+    enabled?: boolean;
+    showLabel?: boolean;
+}>(), {
+    showLabel: true,
+});
+```
+
+### `no-empty-defaults`
+
+`withDefaults(defineProps(...), {})` is redundant.
+
+Options: none.
+
+Fixer: rewrites to `defineProps(...)`.
+
+```ts
+// before
+withDefaults(
+    defineProps<{ 
+        foo?: string
+    }>(),
+    {}
+);
+
+// after
+defineProps<{
+    foo?: string
+}>();
+```

package/index.js

@@ -0,0 +1,34 @@
+import noFalsyDefaultWithOptionalProp from './rules/no-falsy-default-with-optional-prop.js';
+import noBooleanDefaultFalse from './rules/no-boolean-default-false.js';
+import noEmptyWithDefaults from './rules/no-empty-defaults.js';
+import preferOptionalBooleanProp from './rules/prefer-optional-boolean-prop.js';
+
+const plugin = {
+    meta: {
+        name: '@shrpne/eslint-plugin-vue-extra',
+        version: '0.1.0',
+    },
+    rules: {
+        'no-falsy-default-with-optional-prop': noFalsyDefaultWithOptionalProp,
+        'no-boolean-default-false': noBooleanDefaultFalse,
+        'no-empty-defaults': noEmptyWithDefaults,
+        'prefer-optional-boolean-prop': preferOptionalBooleanProp,
+    },
+    configs: {},
+};
+
+Object.assign(plugin.configs, {
+    recommended: {
+        plugins: {
+            'vue-extra': plugin,
+        },
+        rules: {
+            'vue/require-default-prop': 'off',
+            'vue-extra/no-falsy-default-with-optional-prop': 'error',
+            'vue-extra/prefer-optional-boolean-prop': ['error', { fixReferencedTypes: true }],
+            'vue-extra/no-empty-defaults': 'error',
+        },
+    },
+});
+
+export default plugin;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@shrpne/eslint-plugin-vue-extra",
+  "version": "0.1.0",
+  "description": "Extra ESLint rules for Vue projects",
+  "license": "MIT",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "vue",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shrpne/eslint-plugin-vue-extra.git"
+  },
+  "homepage": "https://github.com/shrpne/eslint-plugin-vue-extra#readme",
+  "bugs": {
+    "url": "https://github.com/shrpne/eslint-plugin-vue-extra/issues"
+  },
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "rules",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "publish": "npm publish --access public",
+    "test": "node --test"
+  },
+  "devDependencies": {
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^9.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "eslint": "^9.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/rules/no-boolean-default-false.js

@@ -0,0 +1,259 @@
+import ts from 'typescript';
+
+function getPropNameFromKey(key) {
+    if (!key) return null;
+    if (key.type === 'Identifier') return key.name;
+    if (key.type === 'Literal' && typeof key.value === 'string') return key.value;
+    return null;
+}
+
+function isWithDefaultsCall(node) {
+    return (
+        node &&
+        node.type === 'CallExpression' &&
+        node.callee &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'withDefaults'
+    );
+}
+
+function isDefinePropsCall(node) {
+    return (
+        node &&
+        node.type === 'CallExpression' &&
+        node.callee &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'defineProps'
+    );
+}
+
+function isFalseLiteral(node) {
+    return node && node.type === 'Literal' && node.value === false;
+}
+
+function buildRemovePropertyFix(sourceCode, prop) {
+    const parent = prop.parent;
+    if (!parent || parent.type !== 'ObjectExpression') {
+        return null;
+    }
+
+    const index = parent.properties.indexOf(prop);
+    if (index === -1) {
+        return null;
+    }
+
+    const tokenAfterProp = sourceCode.getTokenAfter(prop);
+    const tokenBeforeProp = sourceCode.getTokenBefore(prop);
+
+    const hasNext = index < parent.properties.length - 1;
+    if (hasNext) {
+        if (!tokenAfterProp || tokenAfterProp.value !== ',') {
+            return null;
+        }
+
+        return (fixer) => fixer.removeRange([prop.range[0], tokenAfterProp.range[1]]);
+    }
+
+    const hasPrev = index > 0;
+    if (hasPrev) {
+        if (!tokenBeforeProp || tokenBeforeProp.value !== ',') {
+            return null;
+        }
+
+        return (fixer) => fixer.removeRange([tokenBeforeProp.range[0], prop.range[1]]);
+    }
+
+    if (parent.properties.length === 1) {
+        return (fixer) => fixer.replaceText(parent, '{}');
+    }
+
+    if (tokenAfterProp && tokenAfterProp.value === ',') {
+        return (fixer) => fixer.removeRange([prop.range[0], tokenAfterProp.range[1]]);
+    }
+
+    return (fixer) => fixer.remove(prop);
+}
+
+function getLineIndent(text, index) {
+    let lineStart = index;
+    while (lineStart > 0 && text[lineStart - 1] !== '\n' && text[lineStart - 1] !== '\r') {
+        lineStart -= 1;
+    }
+
+    let cursor = lineStart;
+    while (cursor < text.length && (text[cursor] === ' ' || text[cursor] === '\t')) {
+        cursor += 1;
+    }
+
+    return text.slice(lineStart, cursor);
+}
+
+function buildReplaceObjectWithoutPropertiesFix(sourceCode, objectNode, propsToRemove) {
+    if (!objectNode || objectNode.type !== 'ObjectExpression') return null;
+    if (!propsToRemove || propsToRemove.size === 0) return null;
+
+    const remaining = objectNode.properties.filter((prop) => !propsToRemove.has(prop));
+    if (remaining.length === objectNode.properties.length) return null;
+
+    if (remaining.length === 0) {
+        return (fixer) => fixer.replaceText(objectNode, '{}');
+    }
+
+    const objectText = sourceCode.getText(objectNode);
+    const isMultiline = objectText.includes('\n') || objectText.includes('\r');
+
+    if (!isMultiline) {
+        const content = remaining.map((prop) => sourceCode.getText(prop)).join(', ');
+        return (fixer) => fixer.replaceText(objectNode, `{ ${content} }`);
+    }
+
+    const fullText = sourceCode.text;
+    const objectIndent = getLineIndent(fullText, objectNode.range[0]);
+    const propertyIndent = getLineIndent(fullText, remaining[0].range[0]) || `${objectIndent}    `;
+    const lines = remaining.map((prop) => `${propertyIndent}${sourceCode.getText(prop)},`);
+    const replacement = `{\n${lines.join('\n')}\n${objectIndent}}`;
+
+    return (fixer) => fixer.replaceText(objectNode, replacement);
+}
+
+function isBooleanLikeType(type) {
+    if (!type) return false;
+
+    if ((type.flags & ts.TypeFlags.BooleanLike) !== 0) return true;
+
+    if ((type.flags & ts.TypeFlags.Union) !== 0 && type.types) {
+        return type.types.some((part) => (part.flags & ts.TypeFlags.BooleanLike) !== 0);
+    }
+
+    return false;
+}
+
+function getOptionalFlag(symbol) {
+    if ((symbol.getFlags() & ts.SymbolFlags.Optional) !== 0) {
+        return true;
+    }
+
+    const declarations = symbol.getDeclarations() || [];
+    for (const declaration of declarations) {
+        if (
+            ts.isPropertySignature(declaration) ||
+            ts.isPropertyDeclaration(declaration) ||
+            ts.isParameter(declaration)
+        ) {
+            if (declaration.questionToken) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+function getPropMetadataFromDefineProps(context, definePropsNode) {
+    const services = context.sourceCode.parserServices;
+    if (!services || !services.program || !services.esTreeNodeToTSNodeMap) return null;
+
+    const checker = services.program.getTypeChecker();
+    const tsNode = services.esTreeNodeToTSNodeMap.get(definePropsNode);
+    if (!tsNode) return null;
+
+    const typeArg = tsNode.typeArguments && tsNode.typeArguments[0];
+    if (!typeArg) return null;
+
+    const type = checker.getTypeFromTypeNode(typeArg);
+    if (!type) return null;
+
+    const map = new Map();
+    for (const symbol of type.getProperties()) {
+        const name = symbol.getName();
+        const propType = checker.getTypeOfSymbolAtLocation(symbol, typeArg);
+
+        map.set(name, {
+            isBooleanLike: isBooleanLikeType(propType),
+            isOptional: getOptionalFlag(symbol),
+        });
+    }
+
+    return map;
+}
+
+const rule = {
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            description:
+                'Disallow `false` defaults for boolean props in withDefaults(defineProps<...>(), { ... })',
+        },
+        schema: [],
+        messages: {
+            noFalseDefault:
+                'Boolean prop "{{name}}" should not default to `false`; this default is redundant.',
+            requiresTypeInfo:
+                '@shrpne/vue-extra/no-boolean-default-false requires type information. Configure @typescript-eslint/parser with parserOptions.project.',
+        },
+    },
+
+    create(context) {
+        const services = context.sourceCode.parserServices;
+        const hasTypeInfo = !!(services && services.program && services.esTreeNodeToTSNodeMap);
+
+        return {
+            CallExpression(node) {
+                if (!isWithDefaultsCall(node)) return;
+                if (node.arguments.length < 2) return;
+
+                const [firstArg, secondArg] = node.arguments;
+                if (!isDefinePropsCall(firstArg)) return;
+                if (!secondArg || secondArg.type !== 'ObjectExpression') return;
+
+                if (!hasTypeInfo) {
+                    context.report({ node, messageId: 'requiresTypeInfo' });
+                    return;
+                }
+
+                const propMetadataMap = getPropMetadataFromDefineProps(context, firstArg);
+                if (!propMetadataMap) return;
+
+                const violations = [];
+                for (const prop of secondArg.properties) {
+                    if (prop.type !== 'Property') continue;
+                    if (prop.computed) continue;
+                    if (prop.kind !== 'init') continue;
+                    if (!isFalseLiteral(prop.value)) continue;
+
+                    const name = getPropNameFromKey(prop.key);
+                    if (!name) continue;
+
+                    const metadata = propMetadataMap.get(name);
+                    if (!metadata || !metadata.isBooleanLike) continue;
+
+                    violations.push({ prop, name });
+                }
+
+                if (violations.length === 0) return;
+
+                const allPropsToRemove = new Set(violations.map((violation) => violation.prop));
+                const sharedFix = buildReplaceObjectWithoutPropertiesFix(
+                    context.sourceCode,
+                    secondArg,
+                    allPropsToRemove
+                );
+
+                for (const violation of violations) {
+                    const removeFix = violations.length > 1
+                        ? sharedFix
+                        : buildRemovePropertyFix(context.sourceCode, violation.prop);
+                    context.report({
+                        node: violation.prop.value,
+                        messageId: 'noFalseDefault',
+                        data: { name: violation.name },
+                        fix: removeFix || null,
+                    });
+                }
+            },
+        };
+    },
+};
+
+export default rule;

package/rules/no-empty-defaults.js

@@ -0,0 +1,48 @@
+function isWithDefaultsCall(node) {
+    return (
+        node &&
+        node.type === 'CallExpression' &&
+        node.callee &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'withDefaults'
+    );
+}
+
+function isEmptyObjectExpression(node) {
+    return node && node.type === 'ObjectExpression' && node.properties.length === 0;
+}
+
+const noEmptyWithDefaults = {
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            description: 'Disallow empty withDefaults(...) wrappers',
+        },
+        schema: [],
+        messages: {
+            noEmptyWithDefaults:
+                '`withDefaults` with an empty defaults object is redundant. Use `defineProps(...)` directly.',
+        },
+    },
+
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!isWithDefaultsCall(node)) return;
+                if (node.arguments.length < 2) return;
+
+                const [firstArg, secondArg] = node.arguments;
+                if (!isEmptyObjectExpression(secondArg)) return;
+
+                context.report({
+                    node,
+                    messageId: 'noEmptyWithDefaults',
+                    fix: (fixer) => fixer.replaceText(node, context.sourceCode.getText(firstArg)),
+                });
+            },
+        };
+    },
+};
+
+export default noEmptyWithDefaults;

package/rules/no-falsy-default-with-optional-prop.js

@@ -0,0 +1,376 @@
+import ts from 'typescript';
+
+/**
+ * Default disallowed values.
+ * Note: user asked for undefined and false; null is included by default because it’s also commonly “falsy default”.
+ */
+const DEFAULT_DISALLOW = ['undefined', 'false'];
+
+function getPropNameFromKey(key) {
+    if (!key) return null;
+    if (key.type === 'Identifier') return key.name;
+    if (key.type === 'Literal' && typeof key.value === 'string') return key.value;
+    return null;
+}
+
+function isDisallowedValue(node, disallowSet) {
+    // false / null / 0 / "" are Literals in ESTree (with @typescript-eslint/parser)
+    if (node.type === 'Literal') {
+        if (node.value === false && disallowSet.has('false')) return true;
+        if (node.value === null && disallowSet.has('null')) return true;
+        if (node.value === 0 && disallowSet.has('0')) return true;
+        if (node.value === '' && disallowSet.has("''")) return true;
+        // NOTE: `undefined` is not a Literal in ESTree
+        return false;
+    }
+
+    // `undefined`
+    if (node.type === 'Identifier' && node.name === 'undefined' && disallowSet.has('undefined')) {
+        return true;
+    }
+
+    // `void 0`
+    if (
+        node.type === 'UnaryExpression' &&
+        node.operator === 'void' &&
+        disallowSet.has('undefined')
+    ) {
+        return true;
+    }
+
+    // empty template literal: `` (rare but possible)
+    if (
+        node.type === 'TemplateLiteral' &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1 &&
+        node.quasis[0].value.raw === '' &&
+        disallowSet.has("''")
+    ) {
+        return true;
+    }
+
+    return false;
+}
+
+function isDefinePropsCall(node) {
+    return (
+        node &&
+        node.type === 'CallExpression' &&
+        node.callee &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'defineProps'
+    );
+}
+
+function isWithDefaultsCall(node) {
+    return (
+        node &&
+        node.type === 'CallExpression' &&
+        node.callee &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'withDefaults'
+    );
+}
+
+function expandRemovalToWholeLine(sourceCode, start, end) {
+    const text = sourceCode.text;
+
+    let lineStart = start;
+    while (lineStart > 0 && text[lineStart - 1] !== '\n' && text[lineStart - 1] !== '\r') {
+        lineStart -= 1;
+    }
+
+    const prefix = text.slice(lineStart, start);
+    if (!/^[ \t]*$/.test(prefix)) {
+        return [start, end];
+    }
+
+    let lineEnd = end;
+    while (lineEnd < text.length && text[lineEnd] !== '\n' && text[lineEnd] !== '\r') {
+        lineEnd += 1;
+    }
+
+    const suffix = text.slice(end, lineEnd);
+    if (!/^[ \t]*$/.test(suffix)) {
+        return [start, end];
+    }
+
+    if (lineEnd < text.length) {
+        if (text[lineEnd] === '\r' && text[lineEnd + 1] === '\n') {
+            lineEnd += 2;
+        } else {
+            lineEnd += 1;
+        }
+    }
+
+    return [lineStart, lineEnd];
+}
+
+function buildRemovePropertyFix(sourceCode, prop) {
+    const parent = prop.parent;
+    if (!parent || parent.type !== 'ObjectExpression') {
+        return null;
+    }
+
+    const index = parent.properties.indexOf(prop);
+    if (index === -1) {
+        return null;
+    }
+
+    const tokenAfterProp = sourceCode.getTokenAfter(prop);
+    const tokenBeforeProp = sourceCode.getTokenBefore(prop);
+
+    const hasNext = index < parent.properties.length - 1;
+    if (hasNext) {
+        if (!tokenAfterProp || tokenAfterProp.value !== ',') {
+            return null;
+        }
+
+        return (fixer) => {
+            const [start, end] = expandRemovalToWholeLine(
+                sourceCode,
+                prop.range[0],
+                tokenAfterProp.range[1]
+            );
+            return fixer.removeRange([start, end]);
+        };
+    }
+
+    const hasPrev = index > 0;
+    if (hasPrev) {
+        if (!tokenBeforeProp || tokenBeforeProp.value !== ',') {
+            return null;
+        }
+
+        return (fixer) => fixer.removeRange([tokenBeforeProp.range[0], prop.range[1]]);
+    }
+
+    if (parent.properties.length === 1) {
+        return (fixer) => fixer.replaceText(parent, '{}');
+    }
+
+    if (tokenAfterProp && tokenAfterProp.value === ',') {
+        return (fixer) => {
+            const [start, end] = expandRemovalToWholeLine(
+                sourceCode,
+                prop.range[0],
+                tokenAfterProp.range[1]
+            );
+            return fixer.removeRange([start, end]);
+        };
+    }
+
+    return (fixer) => fixer.remove(prop);
+}
+
+function getLineIndent(text, index) {
+    let lineStart = index;
+    while (lineStart > 0 && text[lineStart - 1] !== '\n' && text[lineStart - 1] !== '\r') {
+        lineStart -= 1;
+    }
+
+    let cursor = lineStart;
+    while (cursor < text.length && (text[cursor] === ' ' || text[cursor] === '\t')) {
+        cursor += 1;
+    }
+
+    return text.slice(lineStart, cursor);
+}
+
+function buildReplaceObjectWithoutPropertiesFix(sourceCode, objectNode, propsToRemove) {
+    if (!objectNode || objectNode.type !== 'ObjectExpression') return null;
+    if (!propsToRemove || propsToRemove.size === 0) return null;
+
+    const remaining = objectNode.properties.filter((prop) => !propsToRemove.has(prop));
+    if (remaining.length === objectNode.properties.length) return null;
+
+    if (remaining.length === 0) {
+        return (fixer) => fixer.replaceText(objectNode, '{}');
+    }
+
+    const objectText = sourceCode.getText(objectNode);
+    const isMultiline = objectText.includes('\n') || objectText.includes('\r');
+
+    if (!isMultiline) {
+        const content = remaining.map((prop) => sourceCode.getText(prop)).join(', ');
+        return (fixer) => fixer.replaceText(objectNode, `{ ${content} }`);
+    }
+
+    const fullText = sourceCode.text;
+    const objectIndent = getLineIndent(fullText, objectNode.range[0]);
+    const propertyIndent = getLineIndent(fullText, remaining[0].range[0]) || `${objectIndent}    `;
+    const lines = remaining.map((prop) => `${propertyIndent}${sourceCode.getText(prop)},`);
+    const replacement = `{\n${lines.join('\n')}\n${objectIndent}}`;
+
+    return (fixer) => fixer.replaceText(objectNode, replacement);
+}
+
+/**
+ * Extract optional prop names from the TS type behind defineProps<...>().
+ * This uses the TS type checker so it can follow type aliases/interfaces.
+ */
+function getOptionalPropNamesFromDefineProps(context, definePropsNode) {
+    const services = context.sourceCode.parserServices;
+    if (!services || !services.program || !services.esTreeNodeToTSNodeMap) return null;
+
+    const checker = services.program.getTypeChecker();
+
+    // Map the ESTree node to TS node
+    const tsNode = services.esTreeNodeToTSNodeMap.get(definePropsNode);
+    if (!tsNode) return null;
+
+    // defineProps<Props>() has typeArguments on the TS CallExpression node:
+    // tsNode.typeArguments?.[0]
+    const typeArg = tsNode.typeArguments && tsNode.typeArguments[0];
+    if (!typeArg) return null;
+
+    const type = checker.getTypeFromTypeNode(typeArg);
+    if (!type) return null;
+
+    const optional = new Set();
+
+    // Get properties of the type (handles interfaces, type aliases, intersections, etc.)
+    for (const sym of type.getProperties()) {
+        const name = sym.getName();
+
+        // Heuristic 1: SymbolFlags.Optional
+        if ((sym.getFlags() & ts.SymbolFlags.Optional) !== 0) {
+            optional.add(name);
+            continue;
+        }
+
+        // Heuristic 2: inspect declarations for questionToken
+        const decls = sym.getDeclarations() || [];
+        for (const decl of decls) {
+            if (
+                ts.isPropertySignature(decl) ||
+                ts.isPropertyDeclaration(decl) ||
+                ts.isParameter(decl)
+            ) {
+                if (decl.questionToken) {
+                    optional.add(name);
+                    break;
+                }
+            }
+        }
+    }
+
+    return optional;
+}
+
+const rule = {
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description:
+                'Disallow disallowed (falsy) defaults for optional props in withDefaults(defineProps<...>(), { ... })',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    disallow: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                            enum: ['undefined', 'false', 'null', "''", '0'],
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            disallowedDefault:
+                'Optional prop "{{name}}" must not be defaulted to {{value}}.',
+            requiresTypeInfo:
+                '@shrpne/vue-extra/no-falsy-default-with-optional-prop requires type information. Configure @typescript-eslint/parser with parserOptions.project.',
+        },
+    },
+
+    create(context) {
+        const services = context.sourceCode.parserServices;
+        const hasTypeInfo = !!(services && services.program && services.esTreeNodeToTSNodeMap);
+
+        const disallow = new Set(
+            (context.options[0] && context.options[0].disallow) || DEFAULT_DISALLOW
+        );
+
+        function formatValue(node) {
+            if (node.type === 'Identifier' && node.name === 'undefined') return '`undefined`';
+            if (node.type === 'UnaryExpression' && node.operator === 'void') return '`undefined` (via `void`)';
+            if (node.type === 'Literal') {
+                if (node.value === false) return '`false`';
+                if (node.value === null) return '`null`';
+                if (node.value === 0) return '`0`';
+                if (node.value === '') return "empty string (`''`)";
+            }
+            if (node.type === 'TemplateLiteral') return "empty string (``)";
+            return 'a disallowed value';
+        }
+
+        return {
+            CallExpression(node) {
+                if (!isWithDefaultsCall(node)) return;
+                if (node.arguments.length < 2) return;
+
+                const [firstArg, secondArg] = node.arguments;
+
+                // withDefaults(defineProps<...>(), { ... })
+                if (!isDefinePropsCall(firstArg)) return;
+                if (!secondArg || secondArg.type !== 'ObjectExpression') return;
+
+                if (!hasTypeInfo) {
+                    // Only report once per file at the first match; simplest approach is to report here.
+                    context.report({ node, messageId: 'requiresTypeInfo' });
+                    return;
+                }
+
+                const optionalProps = getOptionalPropNamesFromDefineProps(context, firstArg);
+                if (!optionalProps) return;
+
+                const violations = [];
+                for (const prop of secondArg.properties) {
+                    if (prop.type !== 'Property') continue;
+                    if (prop.computed) continue; // ignore computed keys
+                    if (prop.kind !== 'init') continue;
+
+                    const name = getPropNameFromKey(prop.key);
+                    if (!name) continue;
+
+                    // Only enforce for optional props
+                    if (!optionalProps.has(name)) continue;
+
+                    // If the default value is disallowed, report
+                    if (isDisallowedValue(prop.value, disallow)) {
+                        violations.push({ prop, name });
+                    }
+                }
+
+                if (violations.length === 0) return;
+
+                const allPropsToRemove = new Set(violations.map((violation) => violation.prop));
+                const sharedFix = buildReplaceObjectWithoutPropertiesFix(
+                    context.sourceCode,
+                    secondArg,
+                    allPropsToRemove
+                );
+
+                for (const violation of violations) {
+                    const fix = violations.length > 1
+                        ? sharedFix
+                        : buildRemovePropertyFix(context.sourceCode, violation.prop);
+                    context.report({
+                        node: violation.prop.value,
+                        messageId: 'disallowedDefault',
+                        data: { name: violation.name, value: formatValue(violation.prop.value) },
+                        fix,
+                    });
+                }
+            },
+        };
+    },
+};
+
+export default rule;

package/rules/prefer-optional-boolean-prop.js

@@ -0,0 +1,258 @@
+import ts from 'typescript';
+
+function getPropNameFromKey(key) {
+    if (!key) return null;
+    if (key.type === 'Identifier') return key.name;
+    if (key.type === 'Literal' && typeof key.value === 'string') return key.value;
+    return null;
+}
+
+function isWithDefaultsCall(node) {
+    return (
+        node &&
+        node.type === 'CallExpression' &&
+        node.callee &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'withDefaults'
+    );
+}
+
+function isDefinePropsCall(node) {
+    return (
+        node &&
+        node.type === 'CallExpression' &&
+        node.callee &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'defineProps'
+    );
+}
+
+function isBooleanLikeType(type) {
+    if (!type) return false;
+
+    if ((type.flags & ts.TypeFlags.BooleanLike) !== 0) return true;
+
+    if ((type.flags & ts.TypeFlags.Union) !== 0 && type.types) {
+        return type.types.some((part) => (part.flags & ts.TypeFlags.BooleanLike) !== 0);
+    }
+
+    return false;
+}
+
+function getOptionalFlag(symbol) {
+    if ((symbol.getFlags() & ts.SymbolFlags.Optional) !== 0) {
+        return true;
+    }
+
+    const declarations = symbol.getDeclarations() || [];
+    for (const declaration of declarations) {
+        if (
+            ts.isPropertySignature(declaration) ||
+            ts.isPropertyDeclaration(declaration) ||
+            ts.isParameter(declaration)
+        ) {
+            if (declaration.questionToken) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+function getPropMetadataFromDefineProps(context, definePropsNode) {
+    const services = context.sourceCode.parserServices;
+    if (!services || !services.program || !services.esTreeNodeToTSNodeMap) return null;
+
+    const checker = services.program.getTypeChecker();
+    const tsNode = services.esTreeNodeToTSNodeMap.get(definePropsNode);
+    if (!tsNode) return null;
+
+    const typeArg = tsNode.typeArguments && tsNode.typeArguments[0];
+    if (!typeArg) return null;
+
+    const type = checker.getTypeFromTypeNode(typeArg);
+    if (!type) return null;
+
+    const map = new Map();
+    for (const symbol of type.getProperties()) {
+        const name = symbol.getName();
+        const propType = checker.getTypeOfSymbolAtLocation(symbol, typeArg);
+
+        map.set(name, {
+            isBooleanLike: isBooleanLikeType(propType),
+            isOptional: getOptionalFlag(symbol),
+            symbol,
+        });
+    }
+
+    return map;
+}
+
+function getInlineTypeLiteralMemberMap(definePropsNode) {
+    const typeArgs = definePropsNode.typeArguments;
+    if (!typeArgs || !typeArgs.params || typeArgs.params.length === 0) return new Map();
+
+    const firstTypeArg = typeArgs.params[0];
+    if (!firstTypeArg || firstTypeArg.type !== 'TSTypeLiteral') return new Map();
+
+    const members = new Map();
+    for (const member of firstTypeArg.members) {
+        if (member.type !== 'TSPropertySignature') continue;
+        if (!member.key || member.computed) continue;
+
+        const name = getPropNameFromKey(member.key);
+        if (!name) continue;
+
+        members.set(name, member);
+    }
+
+    return members;
+}
+
+function buildMarkOptionalFix(member) {
+    if (!member || member.type !== 'TSPropertySignature') return null;
+    if (member.optional) return null;
+    if (!member.key || !member.key.range) return null;
+
+    return (fixer) => fixer.insertTextAfterRange(member.key.range, '?');
+}
+
+function buildMarkOptionalFixFromSymbol(symbol, currentTsFileName) {
+    if (!symbol) return null;
+
+    const declarations = symbol.getDeclarations() || [];
+    for (const declaration of declarations) {
+        if (
+            !ts.isPropertySignature(declaration) &&
+            !ts.isPropertyDeclaration(declaration) &&
+            !ts.isParameter(declaration)
+        ) {
+            continue;
+        }
+
+        if (declaration.questionToken) continue;
+        if (!declaration.name) continue;
+
+        const sourceFile = declaration.getSourceFile();
+        if (!sourceFile || sourceFile.fileName !== currentTsFileName) {
+            continue;
+        }
+
+        const insertPos = declaration.name.getEnd();
+        return (fixer) => fixer.insertTextAfterRange([insertPos, insertPos], '?');
+    }
+
+    return null;
+}
+
+function getBooleanDefaultsMap(defaultsNode) {
+    const map = new Map();
+
+    for (const prop of defaultsNode.properties) {
+        if (prop.type !== 'Property') continue;
+        if (prop.computed) continue;
+        if (prop.kind !== 'init') continue;
+
+        const name = getPropNameFromKey(prop.key);
+        if (!name) continue;
+
+        if (prop.value.type === 'Literal' && typeof prop.value.value === 'boolean') {
+            map.set(name, prop.value.value);
+            continue;
+        }
+
+        map.set(name, null);
+    }
+
+    return map;
+}
+
+const preferOptionalBooleanProp = {
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            description:
+                'Disallow required boolean props unless they are defaulted to true in withDefaults(...)',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    fixReferencedTypes: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            requiredBooleanNoDefault:
+                'Required boolean prop "{{name}}" should be optional unless it has a `true` default.',
+            requiredBooleanFalseDefault:
+                'Required boolean prop "{{name}}" must not have a `false` default; make it optional or default to `true`.',
+            requiresTypeInfo:
+                '@shrpne/vue-extra/prefer-optional-boolean-prop requires type information. Configure @typescript-eslint/parser with parserOptions.project.',
+        },
+    },
+
+    create(context) {
+        const services = context.sourceCode.parserServices;
+        const hasTypeInfo = !!(services && services.program && services.esTreeNodeToTSNodeMap);
+        const fixReferencedTypes = !!(context.options[0] && context.options[0].fixReferencedTypes);
+
+        const programTsNode = hasTypeInfo
+            ? services.esTreeNodeToTSNodeMap.get(context.sourceCode.ast)
+            : null;
+        const currentTsFileName = programTsNode ? programTsNode.getSourceFile().fileName : null;
+
+        return {
+            CallExpression(node) {
+                if (!isWithDefaultsCall(node)) return;
+                if (node.arguments.length < 2) return;
+
+                const [firstArg, secondArg] = node.arguments;
+                if (!isDefinePropsCall(firstArg)) return;
+                if (!secondArg || secondArg.type !== 'ObjectExpression') return;
+
+                if (!hasTypeInfo) {
+                    context.report({ node, messageId: 'requiresTypeInfo' });
+                    return;
+                }
+
+                const propMetadataMap = getPropMetadataFromDefineProps(context, firstArg);
+                if (!propMetadataMap) return;
+
+                const inlineMembers = getInlineTypeLiteralMemberMap(firstArg);
+                const booleanDefaultsMap = getBooleanDefaultsMap(secondArg);
+
+                for (const [name, metadata] of propMetadataMap.entries()) {
+                    if (!metadata.isBooleanLike) continue;
+                    if (metadata.isOptional) continue;
+
+                    const hasDefault = booleanDefaultsMap.has(name);
+                    const defaultValue = hasDefault ? booleanDefaultsMap.get(name) : null;
+
+                    if (defaultValue === true) continue;
+
+                    const member = inlineMembers.get(name);
+                    const inlineFix = buildMarkOptionalFix(member);
+                    const typeDefinitionFix = fixReferencedTypes && currentTsFileName
+                        ? buildMarkOptionalFixFromSymbol(metadata.symbol, currentTsFileName)
+                        : null;
+                    const fix = inlineFix || typeDefinitionFix || null;
+
+                    context.report({
+                        node: member || node,
+                        messageId: defaultValue === false
+                            ? 'requiredBooleanFalseDefault'
+                            : 'requiredBooleanNoDefault',
+                        data: { name },
+                        fix,
+                    });
+                }
+            },
+        };
+    },
+};
+
+export default preferOptionalBooleanProp;