@elliots/unplugin-typical 0.1.6

package/dist/esbuild.d.mts

@@ -0,0 +1,18 @@
+import { t as Typical } from "./index-BI1Rh2MC.mjs";
+
+//#region src/esbuild.d.ts
+
+/**
+* Esbuild plugin
+*
+* @example
+* ```ts
+* import { build } from 'esbuild'
+* import Typical from '@elliots/unplugin-typical/esbuild'
+*
+* build({ plugins: [Typical()] })
+* ```
+*/
+declare const esbuild: typeof Typical.esbuild;
+//#endregion
+export { esbuild as default, esbuild as "module.exports" };

package/dist/esbuild.mjs

@@ -0,0 +1,24 @@
+import { t as Typical } from "./src-DVJWj1px.mjs";
+
+//#region src/esbuild.ts
+/**
+* This entry file is for esbuild plugin.
+*
+* @module
+*/
+/**
+* Esbuild plugin
+*
+* @example
+* ```ts
+* import { build } from 'esbuild'
+* import Typical from '@elliots/unplugin-typical/esbuild'
+*
+* build({ plugins: [Typical()] })
+* ```
+*/
+const esbuild = Typical.esbuild;
+var esbuild_default = esbuild;
+
+//#endregion
+export { esbuild_default as default, esbuild as "module.exports" };

package/dist/farm.d.mts

@@ -0,0 +1,20 @@
+import { t as Typical } from "./index-BI1Rh2MC.mjs";
+
+//#region src/farm.d.ts
+
+/**
+* Farm plugin
+*
+* @example
+* ```ts
+* // farm.config.ts
+* import Typical from '@elliots/unplugin-typical/farm'
+*
+* export default {
+*   plugins: [Typical()],
+* }
+* ```
+*/
+declare const farm: typeof Typical.farm;
+//#endregion
+export { farm as default, farm as "module.exports" };

package/dist/farm.mjs

@@ -0,0 +1,26 @@
+import { t as Typical } from "./src-DVJWj1px.mjs";
+
+//#region src/farm.ts
+/**
+* This entry file is for Farm plugin.
+*
+* @module
+*/
+/**
+* Farm plugin
+*
+* @example
+* ```ts
+* // farm.config.ts
+* import Typical from '@elliots/unplugin-typical/farm'
+*
+* export default {
+*   plugins: [Typical()],
+* }
+* ```
+*/
+const farm = Typical.farm;
+var farm_default = farm;
+
+//#endregion
+export { farm_default as default, farm as "module.exports" };

package/dist/index-BI1Rh2MC.d.mts

@@ -0,0 +1,34 @@
+import { FilterPattern, UnpluginInstance } from "unplugin";
+import ts from "typescript";
+
+//#region ../../dist/src/config.d.ts
+interface TypicalDebugConfig {
+  writeIntermediateFiles?: 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[];
+}
+//#endregion
+//#region src/core/options.d.ts
+interface Options {
+  include?: FilterPattern;
+  exclude?: FilterPattern;
+  enforce?: "pre" | "post" | undefined;
+  typical?: Partial<TypicalConfig>;
+}
+//#endregion
+//#region src/index.d.ts
+declare const Typical: UnpluginInstance<Options | undefined, false>;
+//#endregion
+export { Options as n, Typical as t };

package/dist/index.d.mts

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

package/dist/index.mjs

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

package/dist/rolldown.d.mts

@@ -0,0 +1,20 @@
+import { t as Typical } from "./index-BI1Rh2MC.mjs";
+
+//#region src/rolldown.d.ts
+
+/**
+* Rolldown plugin
+*
+* @example
+* ```ts
+* // rolldown.config.js
+* import Typical from '@elliots/unplugin-typical/rolldown'
+*
+* export default {
+*   plugins: [Typical()],
+* }
+* ```
+*/
+declare const rolldown: typeof Typical.rolldown;
+//#endregion
+export { rolldown as default, rolldown as "module.exports" };

package/dist/rolldown.mjs

@@ -0,0 +1,26 @@
+import { t as Typical } from "./src-DVJWj1px.mjs";
+
+//#region src/rolldown.ts
+/**
+* This entry file is for Rolldown plugin.
+*
+* @module
+*/
+/**
+* Rolldown plugin
+*
+* @example
+* ```ts
+* // rolldown.config.js
+* import Typical from '@elliots/unplugin-typical/rolldown'
+*
+* export default {
+*   plugins: [Typical()],
+* }
+* ```
+*/
+const rolldown = Typical.rolldown;
+var rolldown_default = rolldown;
+
+//#endregion
+export { rolldown_default as default, rolldown as "module.exports" };

package/dist/rollup.d.mts

@@ -0,0 +1,20 @@
+import { t as Typical } from "./index-BI1Rh2MC.mjs";
+
+//#region src/rollup.d.ts
+
+/**
+* Rollup plugin
+*
+* @example
+* ```ts
+* // rollup.config.js
+* import Typical from '@elliots/unplugin-typical/rollup'
+*
+* export default {
+*   plugins: [Typical()],
+* }
+* ```
+*/
+declare const rollup: typeof Typical.rollup;
+//#endregion
+export { rollup as default, rollup as "module.exports" };

package/dist/rollup.mjs

@@ -0,0 +1,26 @@
+import { t as Typical } from "./src-DVJWj1px.mjs";
+
+//#region src/rollup.ts
+/**
+* This entry file is for Rollup plugin.
+*
+* @module
+*/
+/**
+* Rollup plugin
+*
+* @example
+* ```ts
+* // rollup.config.js
+* import Typical from '@elliots/unplugin-typical/rollup'
+*
+* export default {
+*   plugins: [Typical()],
+* }
+* ```
+*/
+const rollup = Typical.rollup;
+var rollup_default = rollup;
+
+//#endregion
+export { rollup_default as default, rollup as "module.exports" };

package/dist/rspack.d.mts

@@ -0,0 +1,20 @@
+import { t as Typical } from "./index-BI1Rh2MC.mjs";
+
+//#region src/rspack.d.ts
+
+/**
+* Rspack plugin
+*
+* @example
+* ```js
+* // rspack.config.js
+* import Typical from '@elliots/unplugin-typical/rspack'
+*
+* export default {
+*   plugins: [Typical()],
+* }
+* ```
+*/
+declare const rspack: typeof Typical.rspack;
+//#endregion
+export { rspack as default, rspack as "module.exports" };

package/dist/rspack.mjs

@@ -0,0 +1,26 @@
+import { t as Typical } from "./src-DVJWj1px.mjs";
+
+//#region src/rspack.ts
+/**
+* This entry file is for Rspack plugin.
+*
+* @module
+*/
+/**
+* Rspack plugin
+*
+* @example
+* ```js
+* // rspack.config.js
+* import Typical from '@elliots/unplugin-typical/rspack'
+*
+* export default {
+*   plugins: [Typical()],
+* }
+* ```
+*/
+const rspack = Typical.rspack;
+var rspack_default = rspack;
+
+//#endregion
+export { rspack_default as default, rspack as "module.exports" };

package/dist/src-DVJWj1px.mjs

@@ -0,0 +1,112 @@
+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 };

package/dist/vite.d.mts

@@ -0,0 +1,20 @@
+import { t as Typical } from "./index-BI1Rh2MC.mjs";
+
+//#region src/vite.d.ts
+
+/**
+* Vite plugin
+*
+* @example
+* ```ts
+* // vite.config.ts
+* import Typical from '@elliots/unplugin-typical/vite'
+*
+* export default defineConfig({
+*   plugins: [Typical()],
+* })
+* ```
+*/
+declare const vite: typeof Typical.vite;
+//#endregion
+export { vite as default, vite as "module.exports" };

package/dist/vite.mjs

@@ -0,0 +1,26 @@
+import { t as Typical } from "./src-DVJWj1px.mjs";
+
+//#region src/vite.ts
+/**
+* This entry file is for Vite plugin.
+*
+* @module
+*/
+/**
+* Vite plugin
+*
+* @example
+* ```ts
+* // vite.config.ts
+* import Typical from '@elliots/unplugin-typical/vite'
+*
+* export default defineConfig({
+*   plugins: [Typical()],
+* })
+* ```
+*/
+const vite = Typical.vite;
+var vite_default = vite;
+
+//#endregion
+export { vite_default as default, vite as "module.exports" };

package/dist/webpack.d.mts

@@ -0,0 +1,20 @@
+import { t as Typical } from "./index-BI1Rh2MC.mjs";
+
+//#region src/webpack.d.ts
+
+/**
+* Webpack plugin
+*
+* @example
+* ```js
+* // webpack.config.js
+* import Typical from '@elliots/unplugin-typical/webpack'
+*
+* export default {
+*   plugins: [Typical()],
+* }
+* ```
+*/
+declare const webpack: typeof Typical.webpack;
+//#endregion
+export { webpack as default, webpack as "module.exports" };

package/dist/webpack.mjs

@@ -0,0 +1,26 @@
+import { t as Typical } from "./src-DVJWj1px.mjs";
+
+//#region src/webpack.ts
+/**
+* This entry file is for webpack plugin.
+*
+* @module
+*/
+/**
+* Webpack plugin
+*
+* @example
+* ```js
+* // webpack.config.js
+* import Typical from '@elliots/unplugin-typical/webpack'
+*
+* export default {
+*   plugins: [Typical()],
+* }
+* ```
+*/
+const webpack = Typical.webpack;
+var webpack_default = webpack;
+
+//#endregion
+export { webpack_default as default, webpack as "module.exports" };

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@elliots/unplugin-typical",
+  "type": "module",
+  "version": "0.1.6",
+  "description": "Unplugin for typical - runtime safe TypeScript transformer",
+  "author": "Elliot Shepherd <elliot@jarofworms.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/elliots/typical#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/elliots/typical.git",
+    "directory": "packages/unplugin"
+  },
+  "bugs": {
+    "url": "https://github.com/elliots/typical/issues"
+  },
+  "keywords": [
+    "unplugin",
+    "vite",
+    "webpack",
+    "rspack",
+    "rollup",
+    "rolldown",
+    "esbuild",
+    "farm",
+    "typescript",
+    "runtime",
+    "validation",
+    "typical"
+  ],
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./esbuild": "./dist/esbuild.mjs",
+    "./farm": "./dist/farm.mjs",
+    "./rolldown": "./dist/rolldown.mjs",
+    "./rollup": "./dist/rollup.mjs",
+    "./rspack": "./dist/rspack.mjs",
+    "./vite": "./dist/vite.mjs",
+    "./webpack": "./dist/webpack.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*.d.mts",
+        "./*"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@elliots/typical": "0.1.6",
+    "unplugin": "^2.3.11"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsdown": "^0.18.3"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}