@elliots/bun-plugin-typical 0.2.0-beta.1

package/dist/index.d.mts

@@ -0,0 +1,110 @@
+import { BunPlugin } from "bun";
+
+//#region ../../dist/src/config.d.ts
+interface TypicalDebugConfig {
+  writeIntermediateFiles?: boolean;
+}
+/**
+ * Configuration options for source map generation.
+ */
+interface TypicalSourceMapConfig {
+  /**
+   * Generate source maps. Default: true
+   */
+  enabled?: boolean;
+  /**
+   * Include original source content in the map. Default: true
+   */
+  includeContent?: boolean;
+  /**
+   * Use inline source maps (data URL) instead of external files. Default: false
+   */
+  inline?: boolean;
+}
+interface TypicalConfig {
+  include?: string[];
+  exclude?: string[];
+  reusableValidators?: boolean;
+  validateCasts?: boolean;
+  hoistRegex?: boolean;
+  debug?: TypicalDebugConfig;
+  /**
+   * Type patterns to skip validation for (supports wildcards).
+   * Use this for types that typia cannot process (e.g., React event types).
+   * Example: ["React.*", "Express.Request", "*.Event"]
+   */
+  ignoreTypes?: string[];
+  /**
+   * Skip validation for DOM types (Document, Element, Node, etc.) and their subclasses.
+   * These types have complex Window intersections that typia cannot process.
+   * Default: true
+   */
+  ignoreDOMTypes?: boolean;
+  /**
+   * Validate function parameters and return types at runtime.
+   * When enabled, typed function parameters get runtime validation calls injected.
+   * Default: true
+   */
+  validateFunctions?: boolean;
+  /**
+   * Source map generation settings.
+   * Controls whether and how source maps are generated for transformed code.
+   */
+  sourceMap?: TypicalSourceMapConfig;
+}
+//#endregion
+//#region src/core/options.d.ts
+type FilterPattern = string | RegExp | (string | RegExp)[];
+interface Options {
+  /**
+  * Files to include. Defaults to all .ts/.tsx/.mts/.cts files.
+  */
+  include?: FilterPattern;
+  /**
+  * Files to exclude. Defaults to node_modules.
+  */
+  exclude?: FilterPattern;
+  /**
+  * Bun target environment.
+  * @default 'bun'
+  */
+  target?: "bun" | "browser" | "node";
+  /**
+  * Typical configuration overrides.
+  */
+  typical?: Partial<TypicalConfig>;
+}
+//#endregion
+//#region src/core/transform.d.ts
+/**
+* Close the shared transformer and release resources.
+*/
+declare function closeTransformer(): Promise<void>;
+//#endregion
+//#region src/index.d.ts
+/**
+* Create a Bun plugin for Typical transformation.
+*
+* @example
+* ```ts
+* // For Bun.build()
+* import typicalPlugin from '@elliots/bun-plugin-typical'
+*
+* await Bun.build({
+*   entrypoints: ['./src/index.ts'],
+*   outdir: './dist',
+*   plugins: [typicalPlugin()],
+* })
+* ```
+*
+* @example
+* ```ts
+* // For runtime (bunfig.toml preload)
+* import typicalPlugin from '@elliots/bun-plugin-typical'
+*
+* Bun.plugin(typicalPlugin())
+* ```
+*/
+declare function typicalPlugin(rawOptions?: Options): BunPlugin;
+//#endregion
+export { type Options, closeTransformer, typicalPlugin as default, typicalPlugin };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { n as typicalPlugin, r as closeTransformer, t as src_default } from "./src-CBBPzozy.mjs";
+
+export { closeTransformer, src_default as default, typicalPlugin };

package/dist/preload.d.mts

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

package/dist/preload.mjs

@@ -0,0 +1,34 @@
+import { n as typicalPlugin } from "./src-CBBPzozy.mjs";
+
+//#region src/preload.ts
+/**
+* Convenience module for preloading the Typical plugin.
+*
+* @example
+* ```toml
+* # bunfig.toml
+* preload = ["./preload.ts"]
+* ```
+*
+* @example
+* ```ts
+* // preload.ts
+* import '@elliots/bun-plugin-typical/preload'
+* ```
+*
+* Or with custom options:
+* ```ts
+* // preload.ts
+* import { typicalPlugin } from '@elliots/bun-plugin-typical'
+*
+* Bun.plugin(typicalPlugin({
+*   typical: {
+*     reusableValidators: true,
+*   }
+* }))
+* ```
+*/
+Bun.plugin(typicalPlugin());
+
+//#endregion
+export {  };

package/dist/src-CBBPzozy.mjs

@@ -0,0 +1,125 @@
+import { TypicalTransformer, buildTimer, loadConfig, validateConfig } from "@elliots/typical";
+import { extname, resolve } from "path";
+
+//#region src/core/options.ts
+function normalizePattern(pattern) {
+	if (!pattern) return [];
+	if (Array.isArray(pattern)) return pattern;
+	return [pattern];
+}
+function resolveOptions(options) {
+	return {
+		include: normalizePattern(options.include),
+		exclude: options.exclude ? normalizePattern(options.exclude) : [/node_modules/],
+		target: options.target ?? "bun",
+		typical: options.typical
+	};
+}
+
+//#endregion
+//#region src/core/transform.ts
+const TRANSFORM_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+]);
+const LOADER_MAP = {
+	".ts": "ts",
+	".mts": "ts",
+	".cts": "ts",
+	".tsx": "tsx"
+};
+let sharedTransformer = null;
+/**
+* Transform a TypeScript file with Typical.
+*
+* Returns TypeScript code with validation injected.
+* Bun handles the final transpilation to JavaScript.
+*/
+async function transformFile(filePath, config) {
+	buildTimer.start("total-transform");
+	const ext = extname(filePath).toLowerCase();
+	if (!TRANSFORM_EXTENSIONS.has(ext)) {
+		buildTimer.end("total-transform");
+		return;
+	}
+	const resolvedPath = resolve(filePath);
+	buildTimer.start("create-transformer");
+	if (!sharedTransformer) sharedTransformer = new TypicalTransformer(validateConfig(config));
+	buildTimer.end("create-transformer");
+	buildTimer.start("transform");
+	const result = await sharedTransformer.transform(resolvedPath, "ts");
+	buildTimer.end("transform");
+	buildTimer.end("total-transform");
+	if (process.env.DEBUG) console.log(`[bun-plugin-typical] Transformed: ${filePath}`);
+	return {
+		code: result.code,
+		loader: LOADER_MAP[ext] ?? "ts"
+	};
+}
+/**
+* Close the shared transformer and release resources.
+*/
+async function closeTransformer() {
+	if (sharedTransformer) {
+		await sharedTransformer.close();
+		sharedTransformer = null;
+	}
+}
+
+//#endregion
+//#region src/index.ts
+const TS_FILTER = /\.(ts|tsx|mts|cts)$/;
+/**
+* Create a Bun plugin for Typical transformation.
+*
+* @example
+* ```ts
+* // For Bun.build()
+* import typicalPlugin from '@elliots/bun-plugin-typical'
+*
+* await Bun.build({
+*   entrypoints: ['./src/index.ts'],
+*   outdir: './dist',
+*   plugins: [typicalPlugin()],
+* })
+* ```
+*
+* @example
+* ```ts
+* // For runtime (bunfig.toml preload)
+* import typicalPlugin from '@elliots/bun-plugin-typical'
+*
+* Bun.plugin(typicalPlugin())
+* ```
+*/
+function typicalPlugin(rawOptions = {}) {
+	const options = resolveOptions(rawOptions);
+	const typicalConfig = {
+		...loadConfig(),
+		...options.typical
+	};
+	return {
+		name: "bun-plugin-typical",
+		target: options.target,
+		setup(build) {
+			buildTimer.reset();
+			build.onLoad({ filter: TS_FILTER }, async (args) => {
+				if (options.exclude.some((pattern) => typeof pattern === "string" ? args.path.includes(pattern) : pattern.test(args.path))) return;
+				if (options.include.length > 0 && !options.include.some((pattern) => typeof pattern === "string" ? args.path.includes(pattern) : pattern.test(args.path))) return;
+				const result = await transformFile(args.path, typicalConfig);
+				if (!result) return;
+				if (process.env.DEBUG) buildTimer.report("[bun-plugin-typical]");
+				return {
+					contents: result.code,
+					loader: result.loader
+				};
+			});
+		}
+	};
+}
+var src_default = typicalPlugin;
+
+//#endregion
+export { typicalPlugin as n, closeTransformer as r, src_default as t };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@elliots/bun-plugin-typical",
+  "version": "0.2.0-beta.1",
+  "description": "Bun plugin for typical - runtime safe TypeScript transformer",
+  "keywords": [
+    "bun",
+    "runtime",
+    "typescript",
+    "typical",
+    "validation"
+  ],
+  "homepage": "https://github.com/elliots/typical#readme",
+  "bugs": {
+    "url": "https://github.com/elliots/typical/issues"
+  },
+  "license": "MIT",
+  "author": "Elliot Shepherd <elliot@jarofworms.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/elliots/typical.git",
+    "directory": "packages/bun-plugin"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./preload": "./dist/preload.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@elliots/typical": "0.2.0-beta.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.0.0",
+    "@types/node": "^22.0.0",
+    "tsdown": "^0.18.3"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}