eslint-plugin-react-jsx 0.0.0 → 4.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Rel1cx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,15 +1,38 @@
 # eslint-plugin-react-jsx
 
-To install dependencies:
+React Flavored JSX rules for React.
 
-```bash
-bun install
+## Install
+
+```sh
+# npm
+npm install --save-dev eslint-plugin-react-jsx
 ```
 
-To run:
+## Setup
+
+```ts
+import js from "@eslint/js";
+import reactJsx from "eslint-plugin-react-jsx";
+import { defineConfig } from "eslint/config";
+import tseslint from "typescript-eslint";
 
-```bash
-bun run index.ts
+export default defineConfig(
+  {
+    files: ["**/*.{ts,tsx}"],
+    extends: [
+      js.configs.recommended,
+      tseslint.configs.recommended,
+      // Add configs from eslint-plugin-react-jsx
+      reactJsx.configs.recommended,
+    ],
+    rules: {
+      // Put rules you want to override here
+    },
+  },
+);
 ```
 
-This project was created using `bun init` in bun v1.3.10. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.
+## Rules
+
+<https://eslint-react.xyz/docs/rules/overview#jsx-rules>

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { ESLint, Linter } from "eslint";
+
+//#region src/index.d.ts
+type ConfigName = "recommended" | "strict";
+declare const finalPlugin: ESLint.Plugin & {
+  configs: Record<ConfigName, Linter.Config>;
+};
+//#endregion
+export { finalPlugin as default };

package/dist/index.js

@@ -0,0 +1,505 @@
+import { DEFAULT_ESLINT_REACT_SETTINGS, WEBSITE_URL, defineRuleListener } from "@eslint-react/shared";
+import { JsxEmit, findAttribute, getChildren, getElementFullType, getJsxConfig, hasAnyAttribute, hasChildren, isFragmentElement, isHostElement, isWhitespaceText } from "@eslint-react/jsx";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { ESLintUtils } from "@typescript-eslint/utils";
+import * as ast from "@eslint-react/ast";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region package.json
+var name$2 = "eslint-plugin-react-jsx";
+var version = "4.0.0-beta.1";
+
+//#endregion
+//#region src/utils/create-rule.ts
+function getDocsUrl(ruleName) {
+	return `${WEBSITE_URL}/docs/rules/${ruleName}`;
+}
+const createRule = ESLintUtils.RuleCreator(getDocsUrl);
+
+//#endregion
+//#region src/utils/jsx.ts
+/**
+* Trim leading / trailing whitespace the same way React does when rendering
+* JSX text.  Whitespace that contains a newline is stripped entirely;
+* whitespace that stays on the same line is preserved.
+* @param text
+*/
+function trimLikeReact(text) {
+	const leadingSpaces = /^\s*/.exec(text)?.[0] ?? "";
+	const trailingSpaces = /\s*$/.exec(text)?.[0] ?? "";
+	const start = leadingSpaces.includes("\n") ? leadingSpaces.length : 0;
+	const end = trailingSpaces.includes("\n") ? text.length - trailingSpaces.length : text.length;
+	return text.slice(start, end);
+}
+/**
+* Compute the removal range for a JSX attribute, consuming any leading
+* whitespace (spaces, tabs, newlines) so the resulting markup stays clean.
+* @param context
+* @param prop
+*/
+function getPropRemovalRange(context, prop) {
+	const { sourceCode } = context;
+	let start = prop.range[0];
+	const end = prop.range[1];
+	while (start > 0 && /\s/.test(sourceCode.text[start - 1])) start--;
+	return [start, end];
+}
+/**
+* Extract the text to use as JSX children content from a `children` prop.
+*
+* - `children="text"`        -> `text`  (raw string, no quotes)
+* - `children={<div />}`     -> `<div />`  (JSX element, no braces)
+* - `children={<>…</>}`      -> `<>…</>`  (JSX fragment, no braces)
+* - `children={expression}`  -> `{expression}`  (wrapped in braces)
+* - `children`               -> `null`  (boolean shorthand, cannot extract)
+* @param context
+* @param prop
+*/
+function getChildrenPropText(context, prop) {
+	const { sourceCode } = context;
+	const { value } = prop;
+	if (value == null) return null;
+	if (value.type === AST_NODE_TYPES.Literal) return String(value.value);
+	if (value.type === AST_NODE_TYPES.JSXExpressionContainer) {
+		const { expression } = value;
+		if (expression.type === AST_NODE_TYPES.JSXEmptyExpression) return null;
+		const exprText = sourceCode.getText(expression);
+		if (ast.isJSXElementLike(expression)) return exprText;
+		return `{${exprText}}`;
+	}
+	return null;
+}
+/**
+* Compute the range covering **all** children content of a JSX element or
+* fragment (from the start of the first child to the end of the last child).
+*
+* Returns `null` when there are no children at all.
+* @param node
+*/
+function getChildrenContentRange(node) {
+	if (node.children.length === 0) return null;
+	const first = node.children[0];
+	const last = node.children[node.children.length - 1];
+	return [first.range[0], last.range[1]];
+}
+/**
+* Extract the raw source text of an element's / fragment's children
+* (everything between the opening and closing tags).
+*
+* Returns `""` for self-closing elements like `<Fragment />`.
+* @param context
+* @param node
+*/
+function getChildrenSourceText(context, node) {
+	const { sourceCode } = context;
+	const opener = node.type === AST_NODE_TYPES.JSXFragment ? node.openingFragment : node.openingElement;
+	const closer = node.type === AST_NODE_TYPES.JSXFragment ? node.closingFragment : node.closingElement;
+	if (opener.type === AST_NODE_TYPES.JSXOpeningElement && opener.selfClosing) return "";
+	return sourceCode.text.slice(opener.range[1], closer?.range[0]);
+}
+
+//#endregion
+//#region src/rules/no-children-prop-with-children/no-children-prop-with-children.ts
+const RULE_NAME$5 = "no-children-prop-with-children";
+var no_children_prop_with_children_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallows passing 'children' as a prop when children are also passed as nested content." },
+		fixable: "code",
+		hasSuggestions: true,
+		messages: {
+			default: "Do not pass 'children' as a prop when the element already has children content.",
+			removeChildrenContent: "Remove the nested children content.",
+			removeChildrenProp: "Remove the 'children' prop."
+		},
+		schema: []
+	},
+	name: RULE_NAME$5,
+	create: create$5,
+	defaultOptions: []
+});
+function create$5(context) {
+	return defineRuleListener({ JSXElement(node) {
+		const childrenProp = findAttribute(context, node, "children");
+		if (childrenProp == null) return;
+		if (!hasChildren(node)) return;
+		if (childrenProp.type !== AST_NODE_TYPES.JSXAttribute) {
+			context.report({
+				messageId: "default",
+				node: childrenProp
+			});
+			return;
+		}
+		context.report({
+			messageId: "default",
+			node: childrenProp,
+			suggest: [{
+				fix(fixer) {
+					const [start, end] = getPropRemovalRange(context, childrenProp);
+					return fixer.removeRange([start, end]);
+				},
+				messageId: "removeChildrenProp"
+			}, {
+				fix(fixer) {
+					const range = getChildrenContentRange(node);
+					if (range == null) return [];
+					return fixer.removeRange(range);
+				},
+				messageId: "removeChildrenContent"
+			}]
+		});
+	} });
+}
+
+//#endregion
+//#region src/rules/no-children-prop/no-children-prop.ts
+const RULE_NAME$4 = "no-children-prop";
+var no_children_prop_default = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallows passing 'children' as a prop." },
+		fixable: "code",
+		hasSuggestions: true,
+		messages: {
+			default: "Do not pass 'children' as props.",
+			moveChildrenToContent: "Move 'children' to element content."
+		},
+		schema: []
+	},
+	name: RULE_NAME$4,
+	create: create$4,
+	defaultOptions: []
+});
+function create$4(context) {
+	return defineRuleListener({ JSXElement(node) {
+		const childrenProp = findAttribute(context, node, "children");
+		if (childrenProp == null) return;
+		if (childrenProp.type !== AST_NODE_TYPES.JSXAttribute) {
+			context.report({
+				messageId: "default",
+				node: childrenProp
+			});
+			return;
+		}
+		const childrenText = getChildrenPropText(context, childrenProp);
+		if (childrenText == null) {
+			context.report({
+				messageId: "default",
+				node: childrenProp
+			});
+			return;
+		}
+		context.report({
+			messageId: "default",
+			node: childrenProp,
+			suggest: [{
+				fix(fixer) {
+					const sourceCode = context.sourceCode;
+					const { openingElement } = node;
+					const [removeStart, removeEnd] = getPropRemovalRange(context, childrenProp);
+					if (openingElement.selfClosing) {
+						const tagName = sourceCode.getText(openingElement.name);
+						const selfCloseOffset = sourceCode.getText(openingElement).lastIndexOf("/>");
+						let wsStart = openingElement.range[0] + selfCloseOffset;
+						while (wsStart > removeEnd && /\s/.test(sourceCode.text[wsStart - 1])) wsStart--;
+						return [fixer.removeRange([removeStart, removeEnd]), fixer.replaceTextRange([wsStart, openingElement.range[1]], `>${childrenText}</${tagName}>`)];
+					}
+					const fixes = [fixer.removeRange([removeStart, removeEnd])];
+					if (node.closingElement != null) fixes.push(fixer.insertTextBefore(node.closingElement, childrenText));
+					return fixes;
+				},
+				messageId: "moveChildrenToContent"
+			}]
+		});
+	} });
+}
+
+//#endregion
+//#region src/rules/no-comment-textnodes/no-comment-textnodes.ts
+const RULE_NAME$3 = "no-comment-textnodes";
+var no_comment_textnodes_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Prevents comment strings (ex: beginning with '//' or '/*') from being accidentally inserted into a JSX element's text nodes." },
+		messages: { default: "Possible misused comment in text node. Comments inside children section of tag should be placed inside braces." },
+		schema: []
+	},
+	name: RULE_NAME$3,
+	create: create$3,
+	defaultOptions: []
+});
+function create$3(context) {
+	function hasCommentLike(node) {
+		if (ast.isOneOf([AST_NODE_TYPES.JSXAttribute, AST_NODE_TYPES.JSXExpressionContainer])(node.parent)) return false;
+		return /^\s*\/(?:\/|\*)/mu.test(context.sourceCode.getText(node));
+	}
+	const visitorFunction = (node) => {
+		if (!ast.isJSXElementLike(node.parent)) return;
+		if (!hasCommentLike(node)) return;
+		context.report({
+			messageId: "default",
+			node
+		});
+	};
+	return defineRuleListener({
+		JSXText: visitorFunction,
+		Literal: visitorFunction
+	});
+}
+
+//#endregion
+//#region src/rules/no-deoptimization/no-deoptimization.ts
+const RULE_NAME$2 = "no-deoptimization";
+var no_deoptimization_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Prevent patterns that cause deoptimization when using the automatic JSX runtime." },
+		messages: { noKeyAfterSpread: "Placing 'key' after spread props causes deoptimization when using the automatic JSX runtime. Put 'key' before any spread props." },
+		schema: []
+	},
+	name: RULE_NAME$2,
+	create: create$2,
+	defaultOptions: []
+});
+function create$2(context) {
+	const { jsx } = getJsxConfig(context);
+	if (!(jsx === JsxEmit.ReactJSX || jsx === JsxEmit.ReactJSXDev)) return {};
+	return defineRuleListener({ JSXOpeningElement(node) {
+		let firstSpreadPropIndex = null;
+		for (const [index, prop] of node.attributes.entries()) {
+			if (prop.type === AST_NODE_TYPES.JSXSpreadAttribute) {
+				firstSpreadPropIndex ??= index;
+				continue;
+			}
+			if (firstSpreadPropIndex == null) continue;
+			if (prop.name.name === "key" && index > firstSpreadPropIndex) context.report({
+				messageId: "noKeyAfterSpread",
+				node: prop
+			});
+		}
+	} });
+}
+
+//#endregion
+//#region src/rules/no-namespace/no-namespace.ts
+const RULE_NAME$1 = "no-namespace";
+var no_namespace_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow JSX namespace syntax, as React does not support them." },
+		messages: { noNamespace: "A React component '{{name}}' must not be in a namespace, as React does not support them." },
+		schema: []
+	},
+	name: RULE_NAME$1,
+	create: create$1,
+	defaultOptions: []
+});
+function create$1(context) {
+	return defineRuleListener({ JSXElement(node) {
+		const name = getElementFullType(node);
+		if (typeof name !== "string" || !name.includes(":")) return;
+		context.report({
+			data: { name },
+			messageId: "noNamespace",
+			node: node.openingElement.name
+		});
+	} });
+}
+
+//#endregion
+//#region src/rules/no-useless-fragment/no-useless-fragment.ts
+const RULE_NAME = "no-useless-fragment";
+const defaultOptions = [{
+	allowEmptyFragment: false,
+	allowExpressions: true
+}];
+const schema = [{
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		allowEmptyFragment: {
+			type: "boolean",
+			description: "Allow empty fragments"
+		},
+		allowExpressions: {
+			type: "boolean",
+			description: "Allow fragments with a single expression child"
+		}
+	}
+}];
+var no_useless_fragment_default = createRule({
+	meta: {
+		type: "suggestion",
+		defaultOptions: [...defaultOptions],
+		docs: { description: "Disallows useless fragment elements." },
+		fixable: "code",
+		messages: { default: "A fragment {{reason}} is useless." },
+		schema
+	},
+	name: RULE_NAME,
+	create,
+	defaultOptions
+});
+function create(context, [option]) {
+	const { allowEmptyFragment = false, allowExpressions = true } = option;
+	const jsxConfig = getJsxConfig(context);
+	/**
+	* Whether the fragment has too few meaningful children to justify its
+	* existence (the "contains less than two children" reason).
+	* @param node
+	*/
+	function isContentUseless(node) {
+		if (node.children.length === 0) return !allowEmptyFragment;
+		const insideJsx = ast.isJSXElementLike(node.parent);
+		if (!allowExpressions) {
+			if (insideJsx) return true;
+			if (node.children.length === 1) return true;
+		}
+		if (allowExpressions && !insideJsx && node.children.length === 1) {
+			const child = node.children[0];
+			if (child != null && child.type === AST_NODE_TYPES.JSXText) return false;
+		}
+		const meaningful = getChildren(node);
+		if (meaningful.length === 0) return true;
+		if (meaningful.length === 1 && meaningful[0].type !== AST_NODE_TYPES.JSXExpressionContainer) return true;
+		return false;
+	}
+	/**
+	* Whether it is safe to auto-fix the fragment by unwrapping it.
+	* @param node
+	*/
+	function isSafeToFix(node) {
+		if (ast.isJSXElementLike(node.parent)) return isHostElement(node.parent);
+		if (node.children.length === 0) return false;
+		return !node.children.some((child) => {
+			if (child.type === AST_NODE_TYPES.JSXExpressionContainer) return true;
+			if (child.type === AST_NODE_TYPES.JSXText) return !isWhitespaceText(child);
+			return false;
+		});
+	}
+	/**
+	* Build an autofix that unwraps the fragment, replacing it with its
+	* trimmed children text.  Returns `null` when the fix is unsafe.
+	* @param node
+	*/
+	function buildFix(node) {
+		if (!isSafeToFix(node)) return null;
+		return (fixer) => {
+			const childrenText = getChildrenSourceText(context, node);
+			return fixer.replaceText(node, trimLikeReact(childrenText));
+		};
+	}
+	/**
+	* Inspect a fragment node and report if it is useless.
+	*
+	* A fragment may be reported for **two independent reasons** on the same
+	* node (e.g. `<p><>foo</></p>` is both "placed inside a host component"
+	* and* "contains less than two children").
+	* @param node
+	*/
+	function checkNode(node) {
+		if (isHostElement(node.parent)) context.report({
+			data: { reason: "placed inside a host component" },
+			fix: buildFix(node),
+			messageId: "default",
+			node
+		});
+		if (isContentUseless(node)) context.report({
+			data: { reason: "contains less than two children" },
+			fix: buildFix(node),
+			messageId: "default",
+			node
+		});
+	}
+	return defineRuleListener({
+		JSXElement(node) {
+			if (!isFragmentElement(node, jsxConfig.jsxFragmentFactory)) return;
+			if (hasAnyAttribute(context, node, ["key", "ref"])) return;
+			checkNode(node);
+		},
+		JSXFragment(node) {
+			checkNode(node);
+		}
+	});
+}
+
+//#endregion
+//#region src/plugin.ts
+const plugin = {
+	meta: {
+		name: name$2,
+		version
+	},
+	rules: {
+		"no-children-prop": no_children_prop_default,
+		"no-children-prop-with-children": no_children_prop_with_children_default,
+		"no-comment-textnodes": no_comment_textnodes_default,
+		"no-deoptimization": no_deoptimization_default,
+		"no-namespace": no_namespace_default,
+		"no-useless-fragment": no_useless_fragment_default
+	}
+};
+
+//#endregion
+//#region src/configs/recommended.ts
+var recommended_exports = /* @__PURE__ */ __exportAll({
+	name: () => name$1,
+	plugins: () => plugins$1,
+	rules: () => rules$1,
+	settings: () => settings$1
+});
+const name$1 = "react-jsx/recommended";
+const rules$1 = {
+	"react-jsx/no-children-prop": "warn",
+	"react-jsx/no-comment-textnodes": "warn",
+	"react-jsx/no-deoptimization": "error",
+	"react-jsx/no-namespace": "error"
+};
+const plugins$1 = { "react-jsx": plugin };
+const settings$1 = { "react-x": DEFAULT_ESLINT_REACT_SETTINGS };
+
+//#endregion
+//#region src/configs/strict.ts
+var strict_exports = /* @__PURE__ */ __exportAll({
+	name: () => name,
+	plugins: () => plugins,
+	rules: () => rules,
+	settings: () => settings
+});
+const name = "react-jsx/strict";
+const rules = {
+	...rules$1,
+	"react-jsx/no-children-prop": "error",
+	"react-jsx/no-useless-fragment": "warn"
+};
+const plugins = { ...plugins$1 };
+const settings = { ...settings$1 };
+
+//#endregion
+//#region src/index.ts
+const finalPlugin = {
+	...plugin,
+	configs: {
+		["recommended"]: recommended_exports,
+		["strict"]: strict_exports
+	}
+};
+
+//#endregion
+export { finalPlugin as default };

package/package.json

@@ -1,12 +1,78 @@
 {
   "name": "eslint-plugin-react-jsx",
-  "module": "index.ts",
-  "version": "0.0.0",
+  "version": "4.0.0-beta.1",
+  "description": "ESLint React's ESLint plugin for React Flavored JSX rules.",
+  "keywords": [
+    "react",
+    "jsx",
+    "eslint",
+    "eslint-react",
+    "eslint-plugin",
+    "eslint-plugin-react-jsx"
+  ],
+  "homepage": "https://github.com/Rel1cx/eslint-react",
+  "bugs": {
+    "url": "https://github.com/Rel1cx/eslint-react/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rel1cx/eslint-react.git",
+    "directory": "packages/plugins/eslint-plugin-react-jsx"
+  },
+  "license": "MIT",
+  "author": "Rel1cx",
+  "sideEffects": false,
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "./package.json"
+  ],
+  "dependencies": {
+    "@typescript-eslint/scope-manager": "^8.57.2",
+    "@typescript-eslint/types": "^8.57.2",
+    "@typescript-eslint/utils": "^8.57.2",
+    "compare-versions": "^6.1.1",
+    "ts-pattern": "^5.9.0",
+    "@eslint-react/ast": "4.0.0-beta.1",
+    "@eslint-react/core": "4.0.0-beta.1",
+    "@eslint-react/jsx": "4.0.0-beta.1",
+    "@eslint-react/shared": "4.0.0-beta.1",
+    "@eslint-react/var": "4.0.0-beta.1"
+  },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "eslint": "^10.1.0",
+    "tsdown": "^0.21.4",
+    "@local/configs": "0.0.0",
+    "@local/eff": "3.0.0-beta.72"
   },
   "peerDependencies": {
-    "typescript": "^5"
+    "eslint": "^10.0.0",
+    "typescript": "*"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "inlinedDependencies": {
+    "@local/eff": "workspace:*"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "lint:publish": "publint",
+    "lint:ts": "tsl"
   }
 }

package/bun.lock

@@ -1,26 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "eslint-plugin-react-jsx",
-      "devDependencies": {
-        "@types/bun": "latest",
-      },
-      "peerDependencies": {
-        "typescript": "^5",
-      },
-    },
-  },
-  "packages": {
-    "@types/bun": ["@types/bun@1.3.10", "", { "dependencies": { "bun-types": "1.3.10" } }, "sha512-0+rlrUrOrTSskibryHbvQkDOWRJwJZqZlxrUs1u4oOoTln8+WIXBPmAuCF35SWB2z4Zl3E84Nl/D0P7803nigQ=="],
-
-    "@types/node": ["@types/node@25.5.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-jp2P3tQMSxWugkCUKLRPVUpGaL5MVFwF8RDuSRztfwgN1wmqJeMSbKlnEtQqU8UrhTmzEmZdu2I6v2dpp7XIxw=="],
-
-    "bun-types": ["bun-types@1.3.10", "", { "dependencies": { "@types/node": "*" } }, "sha512-tcpfCCl6XWo6nCVnpcVrxQ+9AYN1iqMIzgrSKYMB/fjLtV2eyAVEg7AxQJuCq/26R6HpKWykQXuSOq/21RYcbg=="],
-
-    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
-
-    "undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
-  }
-}

package/index.ts

@@ -1 +0,0 @@
-console.log("Hello via Bun!");

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-  "compilerOptions": {
-    // Environment setup & latest features
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  }
-}