@elliots/unplugin-typical 0.1.7 → 0.1.8

package/dist/esbuild.d.mts

@@ -1,4 +1,4 @@
-import { t as Typical } from "./index-DmCN96cN.mjs";
+import { t as Typical } from "./index-cR_y1bPs.mjs";
 
 //#region src/esbuild.d.ts
 

package/dist/esbuild.mjs

@@ -1,4 +1,4 @@
-import { t as Typical } from "./src-DVJWj1px.mjs";
+import { t as Typical } from "./src-DfYOX15z.mjs";
 
 //#region src/esbuild.ts
 /**

package/dist/farm.d.mts

@@ -1,4 +1,4 @@
-import { t as Typical } from "./index-DmCN96cN.mjs";
+import { t as Typical } from "./index-cR_y1bPs.mjs";
 
 //#region src/farm.d.ts
 

package/dist/farm.mjs

@@ -1,4 +1,4 @@
-import { t as Typical } from "./src-DVJWj1px.mjs";
+import { t as Typical } from "./src-DfYOX15z.mjs";
 
 //#region src/farm.ts
 /**

package/dist/{index-DmCN96cN.d.mts → index-cR_y1bPs.d.mts}

@@ -24,6 +24,12 @@ interface TypicalConfig {
    * 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;
 }
 //#endregion
 //#region src/core/options.d.ts

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { n as Options, t as Typical } from "./index-DmCN96cN.mjs";
+import { n as Options, t as Typical } from "./index-cR_y1bPs.mjs";
 export { Options, Typical };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { t as Typical } from "./src-DVJWj1px.mjs";
+import { t as Typical } from "./src-DfYOX15z.mjs";
 
 export { Typical };

package/dist/rolldown.d.mts

@@ -1,4 +1,4 @@
-import { t as Typical } from "./index-DmCN96cN.mjs";
+import { t as Typical } from "./index-cR_y1bPs.mjs";
 
 //#region src/rolldown.d.ts
 

package/dist/rolldown.mjs

@@ -1,4 +1,4 @@
-import { t as Typical } from "./src-DVJWj1px.mjs";
+import { t as Typical } from "./src-DfYOX15z.mjs";
 
 //#region src/rolldown.ts
 /**

package/dist/rollup.d.mts

@@ -1,4 +1,4 @@
-import { t as Typical } from "./index-DmCN96cN.mjs";
+import { t as Typical } from "./index-cR_y1bPs.mjs";
 
 //#region src/rollup.d.ts
 

package/dist/rollup.mjs

@@ -1,4 +1,4 @@
-import { t as Typical } from "./src-DVJWj1px.mjs";
+import { t as Typical } from "./src-DfYOX15z.mjs";
 
 //#region src/rollup.ts
 /**

package/dist/rspack.d.mts

@@ -1,4 +1,4 @@
-import { t as Typical } from "./index-DmCN96cN.mjs";
+import { t as Typical } from "./index-cR_y1bPs.mjs";
 
 //#region src/rspack.d.ts
 

package/dist/rspack.mjs

@@ -1,4 +1,4 @@
-import { t as Typical } from "./src-DVJWj1px.mjs";
+import { t as Typical } from "./src-DfYOX15z.mjs";
 
 //#region src/rspack.ts
 /**

package/dist/src-DfYOX15z.mjs

@@ -0,0 +1,250 @@
+import { createUnplugin } from "unplugin";
+import { TypicalTransformer, loadConfig } from "@elliots/typical";
+import { dirname, extname, resolve } from "path";
+import ts from "typescript";
+
+//#region src/core/options.ts
+function resolveOptions(options) {
+	return {
+		include: options.include || [/\.[cm]?[jt]sx?$/],
+		exclude: options.exclude || [/node_modules/],
+		enforce: "enforce" in options ? options.enforce : "pre",
+		typical: options.typical
+	};
+}
+
+//#endregion
+//#region src/core/timing.ts
+/**
+* Performance instrumentation for tracking build times
+*/
+var BuildTimer = class {
+	timings = /* @__PURE__ */ new Map();
+	starts = /* @__PURE__ */ new Map();
+	start(stage) {
+		this.starts.set(stage, performance.now());
+	}
+	end(stage) {
+		const start = this.starts.get(stage);
+		if (start !== void 0) {
+			const duration = performance.now() - start;
+			const existing = this.timings.get(stage) ?? [];
+			existing.push(duration);
+			this.timings.set(stage, existing);
+			this.starts.delete(stage);
+		}
+	}
+	reset() {
+		this.timings.clear();
+		this.starts.clear();
+	}
+	report() {
+		console.log("\n[unplugin-typical] Build Performance Report:");
+		console.log("─".repeat(60));
+		const sortedStages = Array.from(this.timings.entries()).sort(([, a], [, b]) => b.reduce((x, y) => x + y, 0) - a.reduce((x, y) => x + y, 0));
+		let totalTime = 0;
+		for (const [stage, times] of sortedStages) {
+			const total = times.reduce((a, b) => a + b, 0);
+			const avg = total / times.length;
+			const min = Math.min(...times);
+			const max = Math.max(...times);
+			const count = times.length;
+			totalTime += total;
+			console.log(`${stage}:`);
+			console.log(`  Count: ${count}`);
+			console.log(`  Total: ${total.toFixed(2)}ms`);
+			console.log(`  Avg:   ${avg.toFixed(2)}ms`);
+			console.log(`  Min:   ${min.toFixed(2)}ms`);
+			console.log(`  Max:   ${max.toFixed(2)}ms`);
+		}
+		console.log("─".repeat(60));
+		console.log(`Total transform time: ${totalTime.toFixed(2)}ms`);
+		console.log("");
+	}
+	getTimings() {
+		const result = /* @__PURE__ */ new Map();
+		for (const [stage, times] of this.timings) {
+			const total = times.reduce((a, b) => a + b, 0);
+			result.set(stage, {
+				count: times.length,
+				total,
+				avg: total / times.length,
+				min: Math.min(...times),
+				max: Math.max(...times)
+			});
+		}
+		return result;
+	}
+};
+const buildTimer = new BuildTimer();
+
+//#endregion
+//#region src/core/transform.ts
+const TRANSFORM_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+]);
+/**
+* Transform a TypeScript file with Typical.
+*
+* Uses a shared ProgramManager for incremental compilation across files.
+*/
+function transformTypia(id, source, config, programManager) {
+	buildTimer.start("total-transform");
+	const ext = extname(id).toLowerCase();
+	if (!TRANSFORM_EXTENSIONS.has(ext)) {
+		buildTimer.end("total-transform");
+		return;
+	}
+	const resolvedId = resolve(id);
+	buildTimer.start("get-program");
+	const program = programManager.getProgram(resolvedId, source);
+	buildTimer.end("get-program");
+	buildTimer.start("get-source-file");
+	const sourceFile = programManager.getSourceFile(resolvedId);
+	buildTimer.end("get-source-file");
+	if (!sourceFile) {
+		buildTimer.end("total-transform");
+		console.warn(`[unplugin-typical] Could not get source file for: ${id}`);
+		return;
+	}
+	buildTimer.start("create-transformer");
+	const transformer = new TypicalTransformer(config, program);
+	buildTimer.end("create-transformer");
+	buildTimer.start("transform");
+	const result = transformer.transform(sourceFile, "js");
+	buildTimer.end("transform");
+	buildTimer.end("total-transform");
+	if (process.env.DEBUG) console.log("[unplugin-typical] Transform output (first 1000 chars):", result.substring(0, 1e3));
+	return result;
+}
+
+//#endregion
+//#region src/core/program-manager.ts
+/**
+* Manages a shared TypeScript program across file transformations.
+* This avoids the expensive cost of creating a new program for each file.
+*/
+var ProgramManager = class {
+	program;
+	compilerOptions;
+	sourceContents = /* @__PURE__ */ new Map();
+	sourceFileCache = /* @__PURE__ */ new Map();
+	host;
+	/**
+	* Get or create a program with the given source content for a file.
+	* Uses incremental compilation to reuse data from previous program.
+	*/
+	getProgram(id, source) {
+		const resolvedId = resolve(id);
+		this.sourceContents.set(resolvedId, source);
+		this.sourceFileCache.delete(resolvedId);
+		if (!this.compilerOptions) {
+			buildTimer.start("load-compiler-options");
+			this.compilerOptions = this.loadCompilerOptions();
+			buildTimer.end("load-compiler-options");
+		}
+		if (!this.host) this.host = this.createHost();
+		const rootFiles = this.program?.getRootFileNames() ?? [];
+		const rootFileSet = new Set(rootFiles);
+		if (!rootFileSet.has(resolvedId)) rootFileSet.add(resolvedId);
+		buildTimer.start("create-program-incremental");
+		this.program = ts.createProgram(Array.from(rootFileSet), this.compilerOptions, this.host, this.program);
+		buildTimer.end("create-program-incremental");
+		return this.program;
+	}
+	/**
+	* Get the source file for a given ID from the current program.
+	*/
+	getSourceFile(id) {
+		const resolvedId = resolve(id);
+		return this.program?.getSourceFile(resolvedId);
+	}
+	/**
+	* Reset the program manager state (e.g., at build start).
+	*/
+	reset() {
+		this.program = void 0;
+		this.sourceContents.clear();
+	}
+	loadCompilerOptions() {
+		const configPath = ts.findConfigFile(process.cwd(), ts.sys.fileExists, "tsconfig.json");
+		if (!configPath) return {
+			target: ts.ScriptTarget.ES2020,
+			module: ts.ModuleKind.ESNext,
+			moduleResolution: ts.ModuleResolutionKind.Bundler,
+			esModuleInterop: true,
+			strict: true
+		};
+		const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+		if (configFile.error) throw new Error(ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n"));
+		return ts.parseJsonConfigFileContent(configFile.config, ts.sys, dirname(configPath)).options;
+	}
+	createHost() {
+		const baseHost = ts.createCompilerHost(this.compilerOptions);
+		const originalGetSourceFile = baseHost.getSourceFile.bind(baseHost);
+		return {
+			...baseHost,
+			getSourceFile: (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+				const resolvedFileName = resolve(fileName);
+				const virtualContent = this.sourceContents.get(resolvedFileName);
+				if (virtualContent !== void 0) {
+					const cached = this.sourceFileCache.get(resolvedFileName);
+					if (cached && cached.text === virtualContent) return cached;
+					const sourceFile = ts.createSourceFile(resolvedFileName, virtualContent, languageVersion, true);
+					this.sourceFileCache.set(resolvedFileName, sourceFile);
+					return sourceFile;
+				}
+				const cachedDisk = this.sourceFileCache.get(resolvedFileName);
+				if (cachedDisk) return cachedDisk;
+				const result = originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+				if (result) this.sourceFileCache.set(resolvedFileName, result);
+				return result;
+			},
+			fileExists: (fileName) => {
+				const resolvedFileName = resolve(fileName);
+				return this.sourceContents.has(resolvedFileName) || baseHost.fileExists(fileName);
+			},
+			readFile: (fileName) => {
+				const resolvedFileName = resolve(fileName);
+				return this.sourceContents.get(resolvedFileName) ?? baseHost.readFile(fileName);
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/index.ts
+const Typical = createUnplugin((rawOptions = {}) => {
+	const options = resolveOptions(rawOptions);
+	const typicalConfig = {
+		...loadConfig(),
+		...options.typical
+	};
+	const programManager = new ProgramManager();
+	return {
+		name: "unplugin-typical",
+		enforce: options.enforce,
+		buildStart() {
+			buildTimer.reset();
+			programManager.reset();
+		},
+		buildEnd() {
+			if (process.env.DEBUG) buildTimer.report();
+		},
+		transform: {
+			filter: { id: {
+				include: options.include,
+				exclude: options.exclude
+			} },
+			handler(code, id) {
+				return transformTypia(id, code, typicalConfig, programManager);
+			}
+		}
+	};
+});
+
+//#endregion
+export { Typical as t };

package/dist/vite.d.mts

@@ -1,4 +1,4 @@
-import { t as Typical } from "./index-DmCN96cN.mjs";
+import { t as Typical } from "./index-cR_y1bPs.mjs";
 
 //#region src/vite.d.ts
 

package/dist/vite.mjs

@@ -1,4 +1,4 @@
-import { t as Typical } from "./src-DVJWj1px.mjs";
+import { t as Typical } from "./src-DfYOX15z.mjs";
 
 //#region src/vite.ts
 /**

package/dist/webpack.d.mts

@@ -1,4 +1,4 @@
-import { t as Typical } from "./index-DmCN96cN.mjs";
+import { t as Typical } from "./index-cR_y1bPs.mjs";
 
 //#region src/webpack.d.ts
 

package/dist/webpack.mjs

@@ -1,4 +1,4 @@
-import { t as Typical } from "./src-DVJWj1px.mjs";
+import { t as Typical } from "./src-DfYOX15z.mjs";
 
 //#region src/webpack.ts
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@elliots/unplugin-typical",
   "type": "module",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Unplugin for typical - runtime safe TypeScript transformer",
   "author": "Elliot Shepherd <elliot@jarofworms.com>",
   "license": "MIT",
@@ -57,7 +57,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@elliots/typical": "0.1.7",
+    "@elliots/typical": "0.1.8",
     "unplugin": "^2.3.11"
   },
   "devDependencies": {

package/dist/src-DVJWj1px.mjs

@@ -1,112 +0,0 @@
-import { createUnplugin } from "unplugin";
-import { TypicalTransformer, loadConfig } from "@elliots/typical";
-import ts from "typescript";
-import { dirname, extname, resolve } from "path";
-
-//#region src/core/options.ts
-function resolveOptions(options) {
-	return {
-		include: options.include || [/\.[cm]?[jt]sx?$/],
-		exclude: options.exclude || [/node_modules/],
-		enforce: "enforce" in options ? options.enforce : "pre",
-		typical: options.typical
-	};
-}
-
-//#endregion
-//#region src/core/transform.ts
-let cachedCompilerOptions;
-const sourceFileCache = /* @__PURE__ */ new Map();
-const TRANSFORM_EXTENSIONS = new Set([
-	".ts",
-	".tsx",
-	".mts",
-	".cts"
-]);
-/**
-* Transform a TypeScript file with Typical.
-*
-* Creates a program per file that includes the provided source content.
-* This ensures the type checker can resolve types for the incoming code.
-*/
-function transformTypia(id, source, config) {
-	const ext = extname(id).toLowerCase();
-	if (!TRANSFORM_EXTENSIONS.has(ext)) return;
-	const { program, sourceFile } = createProgramWithSource(resolve(id), source, getCompilerOptions());
-	const result = new TypicalTransformer(config, program).transform(sourceFile, "js");
-	if (process.env.DEBUG) console.log("[unplugin-typical] Transform output (first 1000 chars):", result.substring(0, 1e3));
-	return result;
-}
-/**
-* Get TypeScript compiler options from tsconfig.json (cached)
-*/
-function getCompilerOptions() {
-	if (cachedCompilerOptions) return cachedCompilerOptions;
-	const configPath = ts.findConfigFile(process.cwd(), ts.sys.fileExists, "tsconfig.json");
-	if (!configPath) {
-		cachedCompilerOptions = {
-			target: ts.ScriptTarget.ES2020,
-			module: ts.ModuleKind.ESNext,
-			moduleResolution: ts.ModuleResolutionKind.Bundler,
-			esModuleInterop: true,
-			strict: true
-		};
-		return cachedCompilerOptions;
-	}
-	const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-	if (configFile.error) throw new Error(ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n"));
-	cachedCompilerOptions = ts.parseJsonConfigFileContent(configFile.config, ts.sys, dirname(configPath)).options;
-	return cachedCompilerOptions;
-}
-/**
-* Create a TypeScript program with the provided source content.
-* Uses a custom compiler host that:
-* - Returns the provided source for the target file
-* - Caches other source files from disk for reuse
-*/
-function createProgramWithSource(id, source, compilerOptions) {
-	const sourceFile = ts.createSourceFile(id, source, compilerOptions.target ?? ts.ScriptTarget.ES2020, true);
-	const host = ts.createCompilerHost(compilerOptions);
-	const originalGetSourceFile = host.getSourceFile.bind(host);
-	host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-		const resolvedFileName = resolve(fileName);
-		if (resolvedFileName === id) return sourceFile;
-		const cached = sourceFileCache.get(resolvedFileName);
-		if (cached) return cached;
-		const result = originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
-		if (result) sourceFileCache.set(resolvedFileName, result);
-		return result;
-	};
-	const program = ts.createProgram([id], compilerOptions, host);
-	if (process.env.DEBUG) console.log("[unplugin-typical] Program source files:", program.getSourceFiles().map((sf) => sf.fileName));
-	return {
-		program,
-		sourceFile: program.getSourceFile(id)
-	};
-}
-
-//#endregion
-//#region src/index.ts
-const Typical = createUnplugin((rawOptions = {}) => {
-	const options = resolveOptions(rawOptions);
-	const typicalConfig = {
-		...loadConfig(),
-		...options.typical
-	};
-	return {
-		name: "unplugin-typical",
-		enforce: options.enforce,
-		transform: {
-			filter: { id: {
-				include: options.include,
-				exclude: options.exclude
-			} },
-			handler(code, id) {
-				return transformTypia(id, code, typicalConfig);
-			}
-		}
-	};
-});
-
-//#endregion
-export { Typical as t };