@rsaf/bundler 0.0.2

package/.prettierrc

@@ -0,0 +1,11 @@
+{
+	"semi": true,
+	"trailingComma": "es5",
+	"singleQuote": true,
+	"printWidth": 100,
+	"tabWidth": 4,
+	"useTabs": true,
+	"bracketSpacing": true,
+	"arrowParens": "avoid",
+	"endOfLine": "lf"
+}

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @rsaf/bundler
+
+## 0.0.2
+
+### Patch Changes
+
+- 7bb0c92: Added Bundler class or bundle app and a CacheStore class

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Riju
+
+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/dist/bundler/Bundler.d.ts

@@ -0,0 +1,60 @@
+import esbuild from 'esbuild';
+import type { BuildResult } from 'esbuild';
+import type { ESBuildConfig } from '../types/config.js';
+/**
+ * EsbuildCompiler
+ *
+ * Thin wrapper around esbuild that provides:
+ * - build
+ * - watch
+ * - rebuild
+ * - close
+ *
+ * It uses esbuild's `context()` + `watch()` APIs under the hood.
+ */
+export declare class Bundler {
+    private options;
+    private context?;
+    private lastResult?;
+    private isWatching;
+    constructor(options: ESBuildConfig);
+    /**
+     * Adds an esbuild plugin to the compiler configuration.
+     */
+    addPlugin(plugin: esbuild.Plugin): this;
+    /**
+     * Performs an initial build or rebuild depending on mode.
+     */
+    build(): Promise<BuildResult>;
+    /**
+     * Enables esbuild's internal watch mode.
+     *
+     * Note:
+     * If you're using chokidar for file watching,
+     * esbuild's onRebuild callback is NOT used anymore.
+     *
+     * Esbuild will still keep its rebuild context alive,
+     * but file watching is controlled externally.
+     */
+    watch(): Promise<void>;
+    /**
+     * Manually trigger a rebuild.
+     *
+     * This is what chokidar will call when a file changes.
+     */
+    rebuild(): Promise<BuildResult>;
+    /**
+     * Dispose of resources.
+     *
+     * Releases esbuild’s internal rebuild/watcher context.
+     */
+    dispose(): Promise<void>;
+    /**
+     * Get last esbuild result.
+     */
+    getLastResult(): BuildResult | undefined;
+    /**
+     * Whether the compiler is currently in watch mode.
+     */
+    isInWatchMode(): boolean;
+}

package/dist/bundler/Bundler.js

@@ -0,0 +1,150 @@
+// compiler.ts
+import { AppError } from '@rsaf/core';
+import esbuild from 'esbuild';
+/**
+ * EsbuildCompiler
+ *
+ * Thin wrapper around esbuild that provides:
+ * - build
+ * - watch
+ * - rebuild
+ * - close
+ *
+ * It uses esbuild's `context()` + `watch()` APIs under the hood.
+ */
+export class Bundler {
+    options;
+    context;
+    lastResult;
+    isWatching = false;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Adds an esbuild plugin to the compiler configuration.
+     */
+    addPlugin(plugin) {
+        if (!this.options.plugins) {
+            this.options.plugins = [];
+        }
+        this.options.plugins.push(plugin);
+        return this;
+    }
+    /**
+     * Performs an initial build or rebuild depending on mode.
+     */
+    async build() {
+        try {
+            if (this.isWatching && this.context) {
+                // In watch mode, we can use rebuild
+                this.lastResult = await this.context.rebuild();
+            }
+            else {
+                // Initial build
+                this.lastResult = await esbuild.build(this.options);
+            }
+            return this.lastResult;
+        }
+        catch (error // eslint-disable-line
+        ) {
+            throw new AppError('Looks like there is some errors while building', {
+                code: 'BUILD_FAILED',
+                category: 'build',
+                cause: error,
+            });
+        }
+    }
+    /**
+     * Enables esbuild's internal watch mode.
+     *
+     * Note:
+     * If you're using chokidar for file watching,
+     * esbuild's onRebuild callback is NOT used anymore.
+     *
+     * Esbuild will still keep its rebuild context alive,
+     * but file watching is controlled externally.
+     */
+    async watch() {
+        if (this.isWatching)
+            return;
+        this.isWatching = true;
+        // If an old context exists, dispose it
+        if (this.context) {
+            await this.dispose();
+        }
+        try {
+            // Create a new esbuild build context
+            this.context = await esbuild.context(this.options);
+            // Start esbuild's watch mode with no onRebuild handlers
+            await this.context.watch();
+        }
+        catch (error // eslint-disable-line
+        ) {
+            throw new AppError('Looks like there is some errors while building', {
+                code: 'BUILD_FAILED',
+                category: 'build',
+                cause: error,
+            });
+        }
+    }
+    /**
+     * Manually trigger a rebuild.
+     *
+     * This is what chokidar will call when a file changes.
+     */
+    async rebuild() {
+        if (!this.context) {
+            throw new AppError('You must call "watch()" before usinf "rebuild()', {
+                code: 'BUILD_FAILED',
+                category: 'build',
+            });
+        }
+        try {
+            this.lastResult = await this.context.rebuild();
+            return this.lastResult;
+        }
+        catch (error //eslint-disable-line
+        ) {
+            throw new AppError('Looks like there is some errors while rebuilding', {
+                code: 'BUILD_FAILED',
+                category: 'build',
+                cause: error,
+            });
+        }
+    }
+    /**
+     * Dispose of resources.
+     *
+     * Releases esbuild’s internal rebuild/watcher context.
+     */
+    async dispose() {
+        if (!this.context)
+            return;
+        try {
+            await this.context.dispose();
+        }
+        catch (error //eslint-disable-line
+        ) {
+            throw new AppError('Failed to stop. Try again', {
+                code: 'BUILD_FAILED',
+                category: 'build',
+                cause: error,
+            });
+        }
+        this.context = undefined;
+        this.lastResult = undefined;
+        this.isWatching = false;
+    }
+    /**
+     * Get last esbuild result.
+     */
+    getLastResult() {
+        return this.lastResult;
+    }
+    /**
+     * Whether the compiler is currently in watch mode.
+     */
+    isInWatchMode() {
+        return this.isWatching;
+    }
+}

package/dist/cache/cache-store.d.ts

@@ -0,0 +1,64 @@
+/**
+ * A type-safe cache that stores values with keys matching a given type structure.
+ * @template T - The type defining the cache's structure: keys as property names and values as corresponding types.
+ */
+export declare class CacheStore<T extends Record<string, any>> {
+    private store;
+    /**
+     * Retrieves a value from the cache by key.
+     * @template K - The specific key type (extends keyof T).
+     * @param key - The key to look up in the cache.
+     * @returns The value associated with the key, or undefined if not found.
+     * @example
+     * // Given T = { name: string, age: number }
+     * cache.get('name'); // Returns string | undefined
+     */
+    get<K extends keyof T>(key: K): T[K] | undefined;
+    /**
+     * Retrieves a value from the cache, throwing an error if the key doesn't exist.
+     * Useful when you expect a key to always be present.
+     * @template K - The specific key type (extends keyof T).
+     * @param key - The key to look up in the cache.
+     * @returns The value associated with the key.
+     * @throws {Error} If the key is not found in the cache.
+     * @example
+     * // Given T = { name: string, age: number }
+     * cache.require('name'); // Returns string, throws if 'name' not found
+     */
+    require<K extends keyof T>(key: K): T[K];
+    /**
+     * Sets a value in the cache for the given key.
+     * @template K - The specific key type (extends keyof T).
+     * @param key - The key to associate with the value.
+     * @param value - The value to store (must match the type T[K]).
+     * @example
+     * // Given T = { name: string, age: number }
+     * cache.set('name', 'Alice'); // OK
+     * cache.set('age', 'thirty'); // Type error: string not assignable to number
+     */
+    set<K extends keyof T>(key: K, value: T[K]): void;
+    /**
+     * Checks if a key exists in the cache.
+     * @template K - The specific key type (extends keyof T).
+     * @param key - The key to check.
+     * @returns True if the key exists in the cache, false otherwise.
+     * @example
+     * cache.has('name'); // Returns boolean
+     */
+    has<K extends keyof T>(key: K): boolean;
+    /**
+     * Removes a key-value pair from the cache.
+     * @template K - The specific key type (extends keyof T).
+     * @param key - The key to remove.
+     * @returns True if the key existed and was removed, false otherwise.
+     * @example
+     * cache.delete('name'); // Returns boolean
+     */
+    delete<K extends keyof T>(key: K): boolean;
+    /**
+     * Removes all key-value pairs from the cache.
+     * @example
+     * cache.clear(); // Empties the entire cache
+     */
+    clear(): void;
+}

package/dist/cache/cache-store.js

@@ -0,0 +1,83 @@
+/**
+ * A type-safe cache that stores values with keys matching a given type structure.
+ * @template T - The type defining the cache's structure: keys as property names and values as corresponding types.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class CacheStore {
+    // Internal storage using Map to maintain key-value pairs
+    store = new Map();
+    /**
+     * Retrieves a value from the cache by key.
+     * @template K - The specific key type (extends keyof T).
+     * @param key - The key to look up in the cache.
+     * @returns The value associated with the key, or undefined if not found.
+     * @example
+     * // Given T = { name: string, age: number }
+     * cache.get('name'); // Returns string | undefined
+     */
+    get(key) {
+        // Type assertion is safe because we only store T[keyof T] values
+        return this.store.get(key);
+    }
+    /**
+     * Retrieves a value from the cache, throwing an error if the key doesn't exist.
+     * Useful when you expect a key to always be present.
+     * @template K - The specific key type (extends keyof T).
+     * @param key - The key to look up in the cache.
+     * @returns The value associated with the key.
+     * @throws {Error} If the key is not found in the cache.
+     * @example
+     * // Given T = { name: string, age: number }
+     * cache.require('name'); // Returns string, throws if 'name' not found
+     */
+    require(key) {
+        const value = this.store.get(key);
+        if (value === undefined) {
+            throw new Error(`Cache key '${String(key)}' is not initialized`);
+        }
+        return value;
+    }
+    /**
+     * Sets a value in the cache for the given key.
+     * @template K - The specific key type (extends keyof T).
+     * @param key - The key to associate with the value.
+     * @param value - The value to store (must match the type T[K]).
+     * @example
+     * // Given T = { name: string, age: number }
+     * cache.set('name', 'Alice'); // OK
+     * cache.set('age', 'thirty'); // Type error: string not assignable to number
+     */
+    set(key, value) {
+        this.store.set(key, value);
+    }
+    /**
+     * Checks if a key exists in the cache.
+     * @template K - The specific key type (extends keyof T).
+     * @param key - The key to check.
+     * @returns True if the key exists in the cache, false otherwise.
+     * @example
+     * cache.has('name'); // Returns boolean
+     */
+    has(key) {
+        return this.store.has(key);
+    }
+    /**
+     * Removes a key-value pair from the cache.
+     * @template K - The specific key type (extends keyof T).
+     * @param key - The key to remove.
+     * @returns True if the key existed and was removed, false otherwise.
+     * @example
+     * cache.delete('name'); // Returns boolean
+     */
+    delete(key) {
+        return this.store.delete(key);
+    }
+    /**
+     * Removes all key-value pairs from the cache.
+     * @example
+     * cache.clear(); // Empties the entire cache
+     */
+    clear() {
+        this.store.clear();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bundler/Bundler.js';
+export * from './cache/cache-store.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+// Bundler
+export * from './bundler/Bundler.js';
+//Cache
+export * from './cache/cache-store.js';

package/dist/types/config.d.ts

@@ -0,0 +1,58 @@
+import type { Loader, Plugin } from 'esbuild';
+export interface ESBuildBaseConfig {
+    minify: boolean;
+    metafile: true;
+    color: true;
+    logLevel: 'silent';
+    treeShaking: true;
+    minifyWhitespace: boolean;
+    minifyIdentifiers: boolean;
+    minifySyntax: boolean;
+    splitting: false;
+    format: 'esm';
+    sourcemap: boolean | 'inline' | 'linked';
+    absWorkingDir: string;
+    outdir?: string;
+    outfile?: string;
+    entryPoints: string[] | Record<string, string>;
+    write?: boolean;
+    plugins: Plugin[];
+}
+export type LoaderFiles = Record<string, Loader>;
+export interface ESBuildClientConfig {
+    platform: 'browser';
+    target: ['es2022'];
+    loader: LoaderFiles;
+    bundle: true;
+    splitting: true;
+}
+export interface ESBuildServerConfig {
+    platform: 'node';
+    target: ['node18'];
+    loader: LoaderFiles;
+    packages: 'external';
+    external: string[];
+    bundle: true;
+    splitting: false;
+}
+export interface ESBuildDevConfig {
+    minify: false;
+    minifyWhitespace: false;
+    minifyIdentifiers: false;
+    minifySyntax: false;
+    sourcemap: 'inline' | true;
+    write: false;
+}
+export interface ESBuildProdConfig {
+    minify: true;
+    minifyWhitespace: true;
+    minifyIdentifiers: true;
+    minifySyntax: true;
+    sourcemap: 'linked' | false;
+    write: true;
+}
+export type ESBuildClientDevConfig = ESBuildBaseConfig & ESBuildClientConfig & ESBuildDevConfig;
+export type ESBuildClientProdConfig = ESBuildBaseConfig & ESBuildClientConfig & ESBuildProdConfig;
+export type ESBuildServerDevConfig = ESBuildBaseConfig & ESBuildServerConfig & ESBuildDevConfig;
+export type ESBuildServerProdConfig = ESBuildBaseConfig & ESBuildServerConfig & ESBuildProdConfig;
+export type ESBuildConfig = ESBuildClientDevConfig | ESBuildClientProdConfig | ESBuildServerDevConfig | ESBuildServerProdConfig;

package/dist/types/config.js

@@ -0,0 +1 @@
+export {};

package/eslint.config.js

@@ -0,0 +1,36 @@
+import baseConfig from '../../eslint.config.js';
+
+export default [
+	...baseConfig,
+	{
+		// Project-specific overrides
+		files: ['**/*.ts'],
+		rules: {
+			// Add these common useful rules
+			semi: ['error', 'always'],
+			'prefer-const': 'error',
+			eqeqeq: ['error', 'always'],
+
+			// TypeScript specific
+			'@typescript-eslint/naming-convention': [
+				'error',
+				{
+					selector: 'variable',
+					format: ['camelCase', 'UPPER_CASE', 'PascalCase'],
+				},
+				{
+					selector: 'typeLike',
+					format: ['PascalCase'],
+				},
+			],
+		},
+	},
+	{
+		// Test-specific configuration
+		files: ['**/*.test.ts', '**/*.spec.ts'],
+		rules: {
+			'no-console': 'off',
+			'@typescript-eslint/no-explicit-any': 'off',
+		},
+	},
+];

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@rsaf/bundler",
+  "version": "0.0.2",
+  "description": "Bundler package for rsaf",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "keywords": [],
+  "author": "Riju Mondal",
+  "license": "MIT",
+  "dependencies": {
+    "@rsaf/core": "^0.0.3",
+    "esbuild": "^0.27.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "lint": "eslint src --max-warnings=0",
+    "lint:fix": "eslint src --fix",
+    "type-check": "tsc --noEmit",
+    "type-check:watch": "tsc --noEmit --watch",
+    "build": "pnpm clean && tsc -b",
+    "dev": "tsc -b --watch",
+    "clean": "rimraf dist tsconfig.tsbuildinfo",
+    "format": "prettier . --write",
+    "format:check": "prettier . --check",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  }
+}

package/src/bundler/Bundler.ts

@@ -0,0 +1,167 @@
+// compiler.ts
+import { AppError } from '@rsaf/core';
+import esbuild from 'esbuild';
+import type { BuildResult } from 'esbuild';
+
+import type { ESBuildConfig } from '../types/config.js';
+
+/**
+ * EsbuildCompiler
+ *
+ * Thin wrapper around esbuild that provides:
+ * - build
+ * - watch
+ * - rebuild
+ * - close
+ *
+ * It uses esbuild's `context()` + `watch()` APIs under the hood.
+ */
+export class Bundler {
+	private options: ESBuildConfig;
+	private context?: esbuild.BuildContext;
+	private lastResult?: BuildResult;
+	private isWatching = false;
+
+	constructor(options: ESBuildConfig) {
+		this.options = options;
+	}
+
+	/**
+	 * Adds an esbuild plugin to the compiler configuration.
+	 */
+	addPlugin(plugin: esbuild.Plugin): this {
+		if (!this.options.plugins) {
+			this.options.plugins = [];
+		}
+		this.options.plugins.push(plugin);
+		return this;
+	}
+
+	/**
+	 * Performs an initial build or rebuild depending on mode.
+	 */
+	async build(): Promise<BuildResult> {
+		try {
+			if (this.isWatching && this.context) {
+				// In watch mode, we can use rebuild
+				this.lastResult = await this.context.rebuild();
+			} else {
+				// Initial build
+				this.lastResult = await esbuild.build(this.options as esbuild.BuildOptions);
+			}
+
+			return this.lastResult;
+		} catch (
+			error: any // eslint-disable-line
+		) {
+			throw new AppError('Looks like there is some errors while building', {
+				code: 'BUILD_FAILED',
+				category: 'build',
+				cause: error,
+			});
+		}
+	}
+
+	/**
+	 * Enables esbuild's internal watch mode.
+	 *
+	 * Note:
+	 * If you're using chokidar for file watching,
+	 * esbuild's onRebuild callback is NOT used anymore.
+	 *
+	 * Esbuild will still keep its rebuild context alive,
+	 * but file watching is controlled externally.
+	 */
+	async watch(): Promise<void> {
+		if (this.isWatching) return;
+
+		this.isWatching = true;
+
+		// If an old context exists, dispose it
+		if (this.context) {
+			await this.dispose();
+		}
+
+		try {
+			// Create a new esbuild build context
+			this.context = await esbuild.context(this.options as esbuild.BuildOptions);
+
+			// Start esbuild's watch mode with no onRebuild handlers
+			await this.context.watch();
+		} catch (
+			error: any // eslint-disable-line
+		) {
+			throw new AppError('Looks like there is some errors while building', {
+				code: 'BUILD_FAILED',
+				category: 'build',
+				cause: error,
+			});
+		}
+	}
+
+	/**
+	 * Manually trigger a rebuild.
+	 *
+	 * This is what chokidar will call when a file changes.
+	 */
+	async rebuild(): Promise<BuildResult> {
+		if (!this.context) {
+			throw new AppError('You must call "watch()" before usinf "rebuild()', {
+				code: 'BUILD_FAILED',
+				category: 'build',
+			});
+		}
+
+		try {
+			this.lastResult = await this.context.rebuild();
+			return this.lastResult;
+		} catch (
+			error: any //eslint-disable-line
+		) {
+			throw new AppError('Looks like there is some errors while rebuilding', {
+				code: 'BUILD_FAILED',
+				category: 'build',
+				cause: error,
+			});
+		}
+	}
+
+	/**
+	 * Dispose of resources.
+	 *
+	 * Releases esbuild’s internal rebuild/watcher context.
+	 */
+	async dispose(): Promise<void> {
+		if (!this.context) return;
+
+		try {
+			await this.context.dispose();
+		} catch (
+			error: any //eslint-disable-line
+		) {
+			throw new AppError('Failed to stop. Try again', {
+				code: 'BUILD_FAILED',
+				category: 'build',
+				cause: error,
+			});
+		}
+
+		this.context = undefined;
+		this.lastResult = undefined;
+		this.isWatching = false;
+	}
+
+	/**
+	 * Get last esbuild result.
+	 */
+	getLastResult(): BuildResult | undefined {
+		return this.lastResult;
+	}
+
+	/**
+	 * Whether the compiler is currently in watch mode.
+	 */
+	isInWatchMode(): boolean {
+		return this.isWatching;
+	}
+}

package/src/cache/cache-store.ts

@@ -0,0 +1,89 @@
+/**
+ * A type-safe cache that stores values with keys matching a given type structure.
+ * @template T - The type defining the cache's structure: keys as property names and values as corresponding types.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class CacheStore<T extends Record<string, any>> {
+	// Internal storage using Map to maintain key-value pairs
+	private store = new Map<keyof T, T[keyof T]>();
+
+	/**
+	 * Retrieves a value from the cache by key.
+	 * @template K - The specific key type (extends keyof T).
+	 * @param key - The key to look up in the cache.
+	 * @returns The value associated with the key, or undefined if not found.
+	 * @example
+	 * // Given T = { name: string, age: number }
+	 * cache.get('name'); // Returns string | undefined
+	 */
+	get<K extends keyof T>(key: K): T[K] | undefined {
+		// Type assertion is safe because we only store T[keyof T] values
+		return this.store.get(key) as T[K] | undefined;
+	}
+
+	/**
+	 * Retrieves a value from the cache, throwing an error if the key doesn't exist.
+	 * Useful when you expect a key to always be present.
+	 * @template K - The specific key type (extends keyof T).
+	 * @param key - The key to look up in the cache.
+	 * @returns The value associated with the key.
+	 * @throws {Error} If the key is not found in the cache.
+	 * @example
+	 * // Given T = { name: string, age: number }
+	 * cache.require('name'); // Returns string, throws if 'name' not found
+	 */
+	require<K extends keyof T>(key: K): T[K] {
+		const value = this.store.get(key);
+		if (value === undefined) {
+			throw new Error(`Cache key '${String(key)}' is not initialized`);
+		}
+		return value as T[K];
+	}
+
+	/**
+	 * Sets a value in the cache for the given key.
+	 * @template K - The specific key type (extends keyof T).
+	 * @param key - The key to associate with the value.
+	 * @param value - The value to store (must match the type T[K]).
+	 * @example
+	 * // Given T = { name: string, age: number }
+	 * cache.set('name', 'Alice'); // OK
+	 * cache.set('age', 'thirty'); // Type error: string not assignable to number
+	 */
+	set<K extends keyof T>(key: K, value: T[K]): void {
+		this.store.set(key, value);
+	}
+
+	/**
+	 * Checks if a key exists in the cache.
+	 * @template K - The specific key type (extends keyof T).
+	 * @param key - The key to check.
+	 * @returns True if the key exists in the cache, false otherwise.
+	 * @example
+	 * cache.has('name'); // Returns boolean
+	 */
+	has<K extends keyof T>(key: K): boolean {
+		return this.store.has(key);
+	}
+
+	/**
+	 * Removes a key-value pair from the cache.
+	 * @template K - The specific key type (extends keyof T).
+	 * @param key - The key to remove.
+	 * @returns True if the key existed and was removed, false otherwise.
+	 * @example
+	 * cache.delete('name'); // Returns boolean
+	 */
+	delete<K extends keyof T>(key: K): boolean {
+		return this.store.delete(key);
+	}
+
+	/**
+	 * Removes all key-value pairs from the cache.
+	 * @example
+	 * cache.clear(); // Empties the entire cache
+	 */
+	clear(): void {
+		this.store.clear();
+	}
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+// Bundler
+export * from './bundler/Bundler.js';
+//Cache
+export * from './cache/cache-store.js';

package/src/types/config.ts

@@ -0,0 +1,95 @@
+import type { Loader, Plugin } from 'esbuild';
+
+// ########################################
+//                ESBuild Config
+// ########################################
+// Base configuration
+export interface ESBuildBaseConfig {
+	// Build optimizations
+	minify: boolean;
+	metafile: true;
+	color: true;
+	logLevel: 'silent';
+
+	// Performance
+	treeShaking: true;
+	minifyWhitespace: boolean;
+	minifyIdentifiers: boolean;
+	minifySyntax: boolean;
+
+	// Code splitting
+	splitting: false;
+
+	// Format
+	format: 'esm';
+
+	// Source maps for debugging
+	sourcemap: boolean | 'inline' | 'linked';
+
+	// Paths
+	absWorkingDir: string;
+	outdir?: string; // Optional in dev mode (memory)
+	outfile?: string; // Alternative to outdir
+	entryPoints: string[] | Record<string, string>;
+
+	// Write to disk or memory
+	write?: boolean; // false = keep in memory (dev mode)
+
+	// Plugins
+	plugins: Plugin[];
+}
+
+export type LoaderFiles = Record<string, Loader>;
+
+// Client-specific configuration
+export interface ESBuildClientConfig {
+	platform: 'browser';
+	target: ['es2022'];
+	loader: LoaderFiles;
+	bundle: true;
+	splitting: true;
+}
+
+// Server-specific configuration
+export interface ESBuildServerConfig {
+	platform: 'node';
+	target: ['node18'];
+	loader: LoaderFiles;
+	packages: 'external';
+	external: string[];
+	bundle: true;
+	splitting: false; // Server doesn't need splitting
+}
+
+// Dev Mode configuration
+export interface ESBuildDevConfig {
+	minify: false;
+	minifyWhitespace: false;
+	minifyIdentifiers: false;
+	minifySyntax: false;
+	sourcemap: 'inline' | true;
+	write: false; // Keep in memory for dev
+}
+
+// Prod Mode configuration
+export interface ESBuildProdConfig {
+	minify: true;
+	minifyWhitespace: true;
+	minifyIdentifiers: true;
+	minifySyntax: true;
+	sourcemap: 'linked' | false;
+	write: true; // Write to disk for prod
+}
+
+// Combined configuration types
+export type ESBuildClientDevConfig = ESBuildBaseConfig & ESBuildClientConfig & ESBuildDevConfig;
+export type ESBuildClientProdConfig = ESBuildBaseConfig & ESBuildClientConfig & ESBuildProdConfig;
+export type ESBuildServerDevConfig = ESBuildBaseConfig & ESBuildServerConfig & ESBuildDevConfig;
+export type ESBuildServerProdConfig = ESBuildBaseConfig & ESBuildServerConfig & ESBuildProdConfig;
+
+// Union type for all possible configs
+export type ESBuildConfig =
+	| ESBuildClientDevConfig
+	| ESBuildClientProdConfig
+	| ESBuildServerDevConfig
+	| ESBuildServerProdConfig;

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+	"extends": "../../tsconfig.base.json",
+
+	"compilerOptions": {
+		// Output settings
+		"target": "ES2022",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+
+		// Project structure
+		"rootDir": "src",
+		"outDir": "dist",
+
+		// Declarations
+		"declaration": true,
+		"emitDeclarationOnly": false,
+
+		// Strictness + compatibility
+		"strict": true,
+		"skipLibCheck": true,
+		"esModuleInterop": true,
+		"resolveJsonModule": true
+	},
+
+	// Files to include
+	"include": ["src"]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/index.ts","./src/bundler/Bundler.ts","./src/cache/cache-store.ts","./src/types/config.ts"],"version":"5.9.3"}