esmate 0.0.0 → 0.0.1

package/package.json

@@ -1,18 +1,51 @@
 {
   "name": "esmate",
-  "version": "0.0.0",
-  "type": "module",
-  "bin": {
-    "esmate": "src/cli.ts"
-  },
+  "version": "0.0.1",
   "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^22.14.0",
-    "typescript": "^5.8.2"
-  },
+  "esmate": "lib",
+  "type": "module",
   "dependencies": {
-    "tsx": "^4.19.3",
     "@inquirer/prompts": "^7.4.1",
-    "tsup": "^8.4.0"
+    "@vitejs/plugin-react-swc": "^3.8.1",
+    "commander": "^13.1.0",
+    "concurrently": "^9.1.2",
+    "es-toolkit": "^1.34.1",
+    "eslint": "^9.24.0",
+    "eslint-config-flat-gitignore": "^2.1.0",
+    "eslint-config-prettier": "^10.1.1",
+    "eslint-plugin-prettier": "^5.2.6",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.19",
+    "find-up": "^7.0.0",
+    "fs-extra": "^11.3.0",
+    "globby": "^14.1.0",
+    "jiti": "^2.4.2",
+    "npm-check-updates": "^17.1.18",
+    "prettier": "^3.5.3",
+    "prettier-plugin-organize-imports": "^4.1.0",
+    "prettier-plugin-tailwindcss": "^0.6.11",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.29.0",
+    "vite": "^6.2.5",
+    "vite-plugin-pages": "^0.33.0",
+    "vite-tsconfig-paths": "^5.1.4",
+    "zod": "^3.24.2"
+  },
+  "bin": {
+    "esm": "src/cli/index.js"
+  },
+  "exports": {
+    "./eslint": {
+      "import": "./src/eslint/index.js",
+      "types": "./src/eslint/index.d.ts"
+    },
+    "./prettier": {
+      "import": "./src/prettier/index.js",
+      "types": "./src/prettier/index.d.ts"
+    },
+    "./vite": {
+      "import": "./src/vite/index.js",
+      "types": "./src/vite/index.d.ts"
+    }
   }
 }

package/src/cli/esmate.d.ts

@@ -0,0 +1,14 @@
+declare class ESMate {
+    private schema;
+    private path;
+    private package;
+    private exports;
+    constructor();
+    get mode(): "app" | "lib";
+    get version(): string;
+    private write;
+    private includeFiles;
+    build(): void;
+}
+export declare const esmate: ESMate;
+export {};

package/src/cli/esmate.js

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import path from 'node:path';
+import { globbySync } from 'globby';
+import { findUpSync } from 'find-up';
+import fs from 'fs-extra';
+class ESMate {
+    constructor() {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: z.object({
+                name: z.string(),
+                version: z.string(),
+                private: z.literal(true),
+                esmate: z.enum(['app', 'lib']),
+                type: z.literal('module'),
+                main: z.undefined({ message: 'The "main" field is not needed for ESM projects.' }),
+                module: z.undefined({ message: 'The "module" field is not needed for ESM projects.' }),
+                scripts: z.record(z.string(), z.string()).optional(),
+                bin: z
+                    .record(z.string(), z.string().refine((value) => fs.existsSync(value), (value) => ({
+                    message: 'No file matches this bin value: ' + value,
+                })))
+                    .optional(),
+                exports: z
+                    .record(z.string().refine((key) => this.exports[key].replace('src/', '').startsWith(key), {
+                    message: 'An export value must be prefixed by its own key.',
+                }), z
+                    .string()
+                    .refine((value) => !value.includes('**'), (value) => ({
+                    message: 'Avoid cross-directory matching in this export value: ' + value,
+                }))
+                    .refine((value) => globbySync(value).length > 0, (value) => ({
+                    message: 'No file matches this export value: ' + value,
+                })))
+                    .optional(),
+                files: z
+                    .array(z.string().refine((value) => globbySync(value).length > 0, (value) => ({
+                    message: 'No file matches this include value: ' + value,
+                })))
+                    .optional(),
+            })
+        });
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: findUpSync('package.json')
+        });
+        Object.defineProperty(this, "package", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fs.readJSONSync(this.path)
+        });
+        Object.defineProperty(this, "exports", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: this.package.exports || {}
+        });
+        this.schema.parse(this.package);
+    }
+    get mode() {
+        return this.package.esmate;
+    }
+    get version() {
+        return this.package.version;
+    }
+    write() {
+        const { dir, base } = path.parse(this.path);
+        const newPackage = Object.assign(Object.assign({}, this.package), { files: undefined, scripts: undefined, private: undefined, devDependencies: undefined, bin: (() => {
+                const newBin = {};
+                for (const key in this.package.bin) {
+                    const value = this.package.bin[key];
+                    const { dir, name } = path.parse(value);
+                    newBin[key] = `${dir}/${name}.js`;
+                }
+                return newBin;
+            })(), exports: (() => {
+                const newExports = {};
+                for (const key in this.package.exports) {
+                    const value = this.package.exports[key];
+                    const { dir, name } = path.parse(value);
+                    const out = `${dir}/${name}`;
+                    newExports[key] = {
+                        import: out + '.js',
+                        types: out + '.d.ts',
+                    };
+                }
+                return newExports;
+            })() });
+        const newPath = path.join(dir, 'dist', base);
+        fs.ensureFileSync(newPath);
+        fs.writeJsonSync(newPath, newPackage, { spaces: 2 });
+    }
+    includeFiles() {
+        for (const filePath of globbySync(this.package.files || [])) {
+            fs.copy(filePath, path.join('dist', filePath));
+        }
+    }
+    build() {
+        this.write();
+        this.includeFiles();
+    }
+}
+export const esmate = new ESMate();

package/src/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S node
+export {};

package/src/cli/index.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env -S node
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Command } from 'commander';
+import { confirm } from '@inquirer/prompts';
+import { esmate } from './esmate.js';
+import { app, lib } from './modes.js';
+import { executeOne, userArgs } from './utils.js';
+const program = new Command();
+program
+    .name('esmate')
+    .description('Build apps and libs with TypeScript following the ECMAScript standard.')
+    .version(esmate.version)
+    .action(() => {
+    program.help();
+});
+program
+    .command('run')
+    .description('run a program')
+    .allowExcessArguments(true)
+    .allowUnknownOption()
+    .option('-h, --help')
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    yield executeOne({
+        name: 'tsx',
+        command: 'npx tsx',
+        args: userArgs,
+        prefixColor: 'blue',
+    });
+}));
+switch (esmate.mode) {
+    case 'app':
+        app(program);
+        break;
+    case 'lib':
+        lib(program);
+        break;
+}
+program
+    .command('lint')
+    .description('lint and format code')
+    .allowExcessArguments(true)
+    .allowUnknownOption()
+    .option('-h, --help')
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    yield executeOne({
+        name: 'eslint',
+        command: 'npx eslint',
+        args: [...userArgs, '.'],
+    });
+    yield executeOne({
+        name: 'prettier',
+        command: 'npx prettier',
+        args: [
+            '--log-level',
+            'warn',
+            '--ignore-unknown',
+            (() => {
+                if (userArgs.includes('--fix')) {
+                    return '--write';
+                }
+                else if (userArgs.includes('--fix-dry-run')) {
+                    return '--list-different';
+                }
+                else {
+                    return '--check';
+                }
+            })(),
+            '.',
+        ],
+        prefixColor: 'cyan',
+    });
+}));
+program
+    .command('update')
+    .description('check and update packages')
+    .allowExcessArguments(true)
+    .allowUnknownOption()
+    .option('-h, --help')
+    .action((script) => __awaiter(void 0, void 0, void 0, function* () {
+    let answer = yield confirm({ message: 'Do you want to update to the latest packages?', default: false });
+    executeOne({
+        name: 'ncu',
+        command: 'ncu',
+        args: ['--interactive', '--target', answer ? 'semver' : 'latest'],
+    });
+}));
+program.parse(process.argv);

package/src/cli/modes.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function app(program: Command): void;
+export declare function lib(program: Command): void;

package/src/cli/modes.js

@@ -0,0 +1,86 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { executeMany, executeOne, userArgs } from './utils.js';
+import { esmate } from './esmate.js';
+export function app(program) {
+    program
+        .command('dev')
+        .description('start dev server')
+        .allowExcessArguments(true)
+        .allowUnknownOption()
+        .option('-h, --help')
+        .action(() => __awaiter(this, void 0, void 0, function* () {
+        yield executeMany([
+            {
+                name: 'vite',
+                command: 'npx vite',
+                args: userArgs,
+                prefixColor: 'cyan',
+            },
+        ]);
+        // https://www.npmjs.com/package/glob-watcher
+        // watch files to fix and format
+    }));
+    program
+        .command('build')
+        .description('build for production')
+        .allowExcessArguments(true)
+        .allowUnknownOption()
+        .option('-h, --help')
+        .action(() => __awaiter(this, void 0, void 0, function* () {
+        yield executeOne({
+            name: 'typescript',
+            command: 'npx tsc --noEmit',
+            args: [],
+            prefixColor: 'blue',
+        });
+        yield executeOne({
+            name: 'vite',
+            command: 'npx vite build',
+            args: [...userArgs, '--emptyOutDir'],
+            prefixColor: 'cyan',
+        });
+    }));
+    program
+        .command('start')
+        .description('serve production build')
+        .allowExcessArguments(true)
+        .allowUnknownOption()
+        .option('-h, --help')
+        .action(() => __awaiter(this, void 0, void 0, function* () {
+        yield executeOne({
+            name: 'vite',
+            command: 'npx vite preview',
+            args: userArgs,
+            prefixColor: 'cyan',
+        });
+    }));
+}
+export function lib(program) {
+    program
+        .command('dev')
+        .description('watch and build')
+        .allowExcessArguments(true)
+        .allowUnknownOption()
+        .option('-h, --help')
+        .action(() => __awaiter(this, void 0, void 0, function* () {
+        esmate.build();
+        yield executeMany([
+            {
+                name: 'typescript',
+                command: 'npx tsc --watch',
+                args: [],
+                prefixColor: 'blue',
+            },
+        ]);
+        // https://www.npmjs.com/package/glob-watcher
+        // watch files to fix and format
+    }));
+}

package/src/cli/utils.d.ts

@@ -0,0 +1,10 @@
+interface Command {
+    name: string;
+    command: string;
+    args: string[];
+    prefixColor?: string;
+}
+export declare const userArgs: string[];
+export declare function executeOne(command: Command): Promise<void>;
+export declare function executeMany(commands: Command[]): Promise<void>;
+export {};

package/src/cli/utils.js

@@ -0,0 +1,35 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import concurrently from 'concurrently';
+import { spawnSync } from 'node:child_process';
+export const userArgs = process.argv.slice(3);
+export function executeOne(command) {
+    return __awaiter(this, void 0, void 0, function* () {
+        spawnSync(command.command, command.args, {
+            cwd: process.cwd(),
+            stdio: 'inherit',
+            shell: true,
+        });
+    });
+}
+export function executeMany(commands) {
+    return __awaiter(this, void 0, void 0, function* () {
+        commands = commands.map((cmd) => {
+            const args = ' ' + cmd.args.map((arg) => arg.trim()).join(' ');
+            const command = cmd.command.trim() + args;
+            return Object.assign(Object.assign({}, cmd), { command, cwd: process.cwd() });
+        });
+        yield concurrently(commands, {
+            killOthers: ['failure', 'success'],
+        })
+            .result.then(() => { })
+            .catch(() => { });
+    });
+}

package/src/eslint/index.d.ts

@@ -0,0 +1,2 @@
+export { defineConfig } from './shared.js';
+export { react } from './react.js';

package/src/eslint/index.js

@@ -0,0 +1,2 @@
+export { defineConfig } from './shared.js';
+export { react } from './react.js';

package/src/eslint/node.d.ts

@@ -0,0 +1 @@
+export declare function node(): import("eslint").Linter.Config<import("eslint").Linter.RulesRecord>[];

package/src/eslint/node.js

@@ -0,0 +1,15 @@
+import globals from 'globals';
+import javaScript from '@eslint/js';
+import typeScript from 'typescript-eslint';
+import gitIgnore from 'eslint-config-flat-gitignore';
+import { prettier } from './shared.js';
+import { defineConfig, languageOptions } from './shared.js';
+export function node() {
+    return defineConfig([
+        {
+            files: ['**/*.?(c|m)[jt]s?(x)'],
+            languageOptions: Object.assign(Object.assign({}, languageOptions), { globals: globals.node }),
+            extends: [gitIgnore(), javaScript.configs.recommended, ...typeScript.configs.recommended, prettier()],
+        },
+    ]);
+}

package/src/eslint/react.d.ts

@@ -0,0 +1 @@
+export declare function react(): import("eslint").Linter.Config<import("eslint").Linter.RulesRecord>[];

package/src/eslint/react.js

@@ -0,0 +1,24 @@
+import globals from 'globals';
+import javaScript from '@eslint/js';
+import typeScript from 'typescript-eslint';
+import reactHooks from 'eslint-plugin-react-hooks';
+import reactRefresh from 'eslint-plugin-react-refresh';
+import gitIgnore from 'eslint-config-flat-gitignore';
+import { prettier } from './shared.js';
+import { defineConfig, languageOptions } from './shared.js';
+export function react() {
+    return defineConfig([
+        {
+            files: ['**/*.?(c|m)[jt]s?(x)'],
+            languageOptions: Object.assign(Object.assign({}, languageOptions), { globals: globals.browser }),
+            extends: [
+                gitIgnore(),
+                javaScript.configs.recommended,
+                ...typeScript.configs.recommended,
+                reactHooks.configs['recommended-latest'],
+                reactRefresh.configs.vite,
+                prettier(),
+            ],
+        },
+    ]);
+}

package/src/eslint/shared.d.ts

@@ -0,0 +1,5 @@
+import { Linter } from 'eslint';
+import { defineConfig } from 'eslint/config';
+export { defineConfig };
+export declare function prettier(): Linter.Config<Linter.RulesRecord>[];
+export declare const languageOptions: Linter.LanguageOptions;

package/src/eslint/shared.js

@@ -0,0 +1,20 @@
+import { defineConfig } from 'eslint/config';
+import prettierPlugin from 'eslint-plugin-prettier';
+import prettierConfig from 'eslint-config-prettier';
+export { defineConfig };
+export function prettier() {
+    return defineConfig([
+        {
+            plugins: {
+                prettier: prettierPlugin,
+            },
+            extends: [prettierConfig],
+            rules: {
+                'prettier/prettier': ['warn'],
+            },
+        },
+    ]);
+}
+export const languageOptions = {
+    ecmaVersion: 2020,
+};

package/src/prettier/index.d.ts

@@ -0,0 +1,2 @@
+export { defineConfig } from './shared.js';
+export { tailwind } from './tailwind.js';

package/src/prettier/index.js

@@ -0,0 +1,2 @@
+export { defineConfig } from './shared.js';
+export { tailwind } from './tailwind.js';

package/src/prettier/shared.d.ts

@@ -0,0 +1,2 @@
+import { Config } from 'prettier';
+export declare function defineConfig(configs: Config[]): Config;

package/src/prettier/shared.js

@@ -0,0 +1,30 @@
+import { uniq } from 'es-toolkit';
+export function defineConfig(configs) {
+    const defaultConfig = {
+        tabWidth: 2,
+        semi: true,
+        printWidth: 120,
+        singleQuote: true,
+        trailingComma: 'es5',
+        plugins: ['prettier-plugin-organize-imports'],
+    };
+    for (const config of configs) {
+        for (const key in config) {
+            const value = config[key];
+            if (key === 'plugins') {
+                const plugins = defaultConfig.plugins || [];
+                defaultConfig.plugins = uniq([...plugins, ...value]);
+            }
+            // if (isJSONArray(value)) {
+            //   const array = (defaultConfig[key] as undefined) || [];
+            //   defaultConfig[key] = uniq([...array, ...value]);
+            // } else if (isJSONObject(value)) {
+            //   const object = (defaultConfig[key] as undefined) || {};
+            //   defaultConfig[key] = { ...object, ...value };
+            // } else {
+            //   defaultConfig[key] = value;
+            // }
+        }
+    }
+    return defaultConfig;
+}

package/src/prettier/tailwind.d.ts

@@ -0,0 +1,10 @@
+interface Options {
+    tailwindFunctions: string[];
+    tailwindConfig?: string;
+    tailwindStylesheet?: string;
+    tailwindAttributes?: string[];
+    tailwindPreserveWhitespace?: boolean;
+    tailwindPreserveDuplicates?: boolean;
+}
+export declare function tailwind(options: Options): import("prettier").Config;
+export {};

package/src/prettier/tailwind.js

@@ -0,0 +1,4 @@
+import { defineConfig } from './shared.js';
+export function tailwind(options) {
+    return defineConfig([Object.assign({ plugins: ['prettier-plugin-tailwindcss'] }, options)]);
+}

package/src/vite/index.d.ts

@@ -0,0 +1,2 @@
+export { defineConfig } from 'vite';
+export * as react from './react.js';

package/src/vite/index.js

@@ -0,0 +1,2 @@
+export { defineConfig } from 'vite';
+export * as react from './react.js';

package/src/vite/react.d.ts

@@ -0,0 +1,20 @@
+import pages from 'vite-plugin-pages';
+import paths from 'vite-tsconfig-paths';
+import react from '@vitejs/plugin-react-swc';
+interface SpaOptions {
+    react: Parameters<typeof react>[0];
+    pages: Parameters<typeof pages>[0];
+    paths: Parameters<typeof paths>[0];
+}
+export declare function spa(options?: SpaOptions): {
+    name: string;
+    config: () => {
+        root: string;
+        build: {
+            outDir: string;
+        };
+        plugins: (import("vite").Plugin<any> | import("vite").PluginOption[])[];
+    };
+};
+export declare function lib(): {};
+export {};

package/src/vite/react.js

@@ -0,0 +1,16 @@
+import pages from 'vite-plugin-pages';
+import paths from 'vite-tsconfig-paths';
+import react from '@vitejs/plugin-react-swc';
+export function spa(options) {
+    return {
+        name: 'react-app',
+        config: () => ({
+            root: './src',
+            build: { outDir: '../dist' },
+            plugins: [paths(options === null || options === void 0 ? void 0 : options.paths), pages(options === null || options === void 0 ? void 0 : options.pages), react(options === null || options === void 0 ? void 0 : options.react)],
+        }),
+    };
+}
+export function lib() {
+    return {};
+}

package/src/cli.ts

@@ -1,90 +0,0 @@
-#!/usr/bin/env -S tsx
-
-import { confirm } from '@inquirer/prompts';
-import { spawnSync } from 'node:child_process';
-
-type Command = 'dev' | 'build' | 'start' | 'test' | 'lint' | 'update';
-type Commands = Record<Command, { description: string; action: () => void }>;
-
-const args = process.argv.slice(3);
-const command: Command = process.argv[2] as any;
-
-function exec(command: string, args: string[] = []) {
-  // console.log(`> ${command} ${args.join(' ')}`);
-
-  spawnSync(command, [...args], { cwd: process.cwd(), stdio: 'inherit', shell: true });
-}
-
-const commands: Commands = {
-  dev: {
-    description: 'start dev server',
-    action: () => {
-      exec('vite', [...args]);
-    },
-  },
-  build: {
-    description: 'build for production',
-    action: () => {
-      exec('tsc --noEmit');
-      exec('tsup', [...args]);
-    },
-  },
-  start: {
-    description: 'serve production build',
-    action: () => {
-      exec('vite', ['preview', ...args]);
-    },
-  },
-  lint: {
-    description: 'lint and format code',
-    action: () => {
-      const include = (yes: boolean) => `'${(yes ? '' : '!') + '**/*.?(c|m)[jt]s?(x)'}'`;
-
-      exec('eslint', ['--ignore-path', '.gitignore', ...args, include(true)]);
-
-      let fmtArg = '';
-
-      if (args.includes('--fix')) {
-        fmtArg = '--write';
-      } else if (args.includes('--fix-dry-run')) {
-        fmtArg = '--list-different';
-      } else {
-        fmtArg = '--check';
-      }
-
-      exec('prettier', ['--log-level', 'warn', fmtArg, '.', include(false)]);
-    },
-  },
-  test: {
-    description: 'start test runner',
-    action: () => {
-      exec('vitest', [...args]);
-    },
-  },
-  update: {
-    description: 'check and update packages',
-    action: async () => {
-      let answer = await confirm({ message: 'Yes to update safely or No to update to the latest:' });
-
-      exec('ncu', ['--interactive', '--target', answer ? 'semver' : 'latest']);
-    },
-  },
-  // cover: {
-  //   description: 'print coverage reports',
-  //   action: () => {
-  //     exec('vitest', ['run', '--coverage', ...args]);
-  //   },
-  // },
-};
-
-if (commands[command]) {
-  commands[command].action();
-} else {
-  console.log('A tool for building single-page apps.\n');
-
-  for (const [command, { description }] of Object.entries(commands)) {
-    console.log(`spa ${command.padEnd(7, ' ')} ${description}`);
-  }
-
-  console.log('\nDocs: https://create-spa-app.deno.dev/');
-}

package/template/package.json

@@ -1,25 +0,0 @@
-{
-  "name": "esmate",
-  "version": "1.0.0",
-  "license": "MIT",
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "dev": "tsup --watch",
-    "build": "tsup"
-  },
-  "devDependencies": {
-    "@types/node": "^22.14.0",
-    "typescript": "^5.8.2"
-  }
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["ES2021"],
-    "module": "ESNext",
-    "noEmit": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "isolatedModules": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "bundler",
-    "useDefineForClassFields": true,
-    "allowImportingTsExtensions": true
-  },
-  "include": ["src"]
-}

package/tsup.config.ts

@@ -1,11 +0,0 @@
-// tsup.config.ts
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: ['src/index.ts', 'src/cli.ts'],
-  format: 'esm',
-  target: 'node12',
-  dts: true,
-  clean: true,
-  sourcemap: true,
-});