@liautaud/typezod 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Romain Liautaud
+
+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/README.md

@@ -0,0 +1,91 @@
+# typezod
+
+Zod-like DSL for comparing TypeScript compiler types against
+user-defined schemas.
+
+## Why?
+
+Writing type-aware ESLint rules (or codemods, code generators, etc.) means
+working with the TypeScript compiler's `ts.Type` objects. Checking whether
+a type matches a specific schema quickly turns into verbose, repetitive
+calls to `checker.isTypeAssignableTo()`, `type.getProperty()`, and friends.
+
+This library lets you **declare** the types you care about with a concise,
+Zod-inspired API and then ask "is this compiler type assignable to my
+schema?" in a single call.
+
+## Usage
+
+```typescript
+import { t, isAssignableTo, type SchemaContext } from "@liautaud/typezod";
+
+// Define schemas for the types you want to check against.
+const Rectangle = t.object({
+  x: t.number(),
+  y: t.number(),
+  width: t.number(),
+  height: t.number(),
+});
+
+const ElectronWindow = t.fromModule("/electron/", "BaseWindow");
+
+// Inside a typescript-eslint rule's `create()` function, build a context
+// from the parser services and use `isAssignableTo` to check types.
+const checker = parserServices.program.getTypeChecker();
+const ctx: SchemaContext = { checker, program: parserServices.program };
+
+if (isAssignableTo(ctx, objectType, ElectronWindow)) {
+  if (!isAssignableTo(ctx, argType, Rectangle)) {
+    context.report({ ... });
+  }
+}
+```
+
+## API
+
+### `isAssignableTo(ctx, type, schema)`
+
+Returns `true` if the given `ts.Type` is assignable to the type represented
+by the schema.
+
+### `SchemaContext`
+
+The context object passed to `isAssignableTo`. Contains a `checker`
+(required) and an optional `program` (only needed for `t.fromModule()`).
+
+### Primitives
+
+| Builder          | Description                    |
+| ---------------- | ------------------------------ |
+| `t.string()`     | Represents the `string` type   |
+| `t.number()`     | Represents the `number` type   |
+| `t.boolean()`    | Represents the `boolean` type  |
+| `t.void()`       | Represents the `void` type     |
+| `t.undefined()`  | Represents the `undefined` type|
+| `t.null()`       | Represents the `null` type     |
+| `t.any()`        | Accepts any type               |
+| `t.unknown()`    | Accepts any type               |
+
+### Combinators
+
+| Builder                    | Description                                                      |
+| -------------------------- | ---------------------------------------------------------------- |
+| `t.object(shape)`          | Represents an object with the given shape (structural subtyping) |
+| `t.array(element)`         | Represents an array whose element satisfies the given schema     |
+| `t.union(...schemas)`      | Represents a union of the given schemas                          |
+| `t.intersection(...schemas)` | Represents an intersection of the given schemas                |
+
+### Advanced
+
+| Builder                                 | Description                                             |
+| --------------------------------------- | ------------------------------------------------------- |
+| `t.fromModule(pathPattern, exportName)` | Represents a type exported from a module in the program |
+| `t.custom(fn)`                          | Escape hatch for arbitrary predicates                   |
+
+### Modifiers
+
+| Modifier      | Description                                                       |
+| ------------- | ----------------------------------------------------------------- |
+| `.optional()` | Inside `t.object()`, allows the property to be absent or optional |
+| `.nullable()` | Also accepts `null`                                               |
+| `.nullish()`  | Also accepts `null \| undefined`                                  |

package/dist/index.d.ts

@@ -0,0 +1,176 @@
+import { Program, Type, TypeChecker } from "typescript";
+
+//#region src/index.d.ts
+
+/**
+ * Context required by all schema checks. The `program` field is only needed
+ * for schemas that resolve types from external modules ({@link t.fromModule}).
+ */
+type SchemaContext = {
+  checker: TypeChecker;
+  program?: Program;
+};
+type AcceptsFn = (type: Type, ctx: SchemaContext) => boolean;
+/**
+ * A type schema that checks whether a TypeScript compiler type is assignable
+ * to the type represented by the schema.
+ *
+ * Obtain instances through the {@link t} builder, never instantiate directly.
+ */
+declare class TypeSchema {
+  /** @internal */
+  readonly _accepts: AcceptsFn;
+  /** @internal */
+  readonly _isOptional: boolean;
+  /** @internal */
+  constructor(accepts: AcceptsFn, isOptional?: boolean);
+  /**
+   * Marks this schema as optional when used as a property in {@link t.object}.
+   * An optional property may be absent from the type or carry the TypeScript
+   * `Optional` symbol flag.
+   *
+   * @example
+   * ```typescript
+   * const Shape = t.object({
+   *   label: t.string().optional(),
+   * });
+   * ```
+   */
+  optional(): TypeSchema;
+  /**
+   * Wraps this schema to also accept `null`.
+   *
+   * @example
+   * ```typescript
+   * const MaybeNumber = t.number().nullable(); // number | null
+   * ```
+   */
+  nullable(): TypeSchema;
+  /**
+   * Wraps this schema to also accept `null` and `undefined`.
+   *
+   * @example
+   * ```typescript
+   * const MaybeNumber = t.number().nullish(); // number | null | undefined
+   * ```
+   */
+  nullish(): TypeSchema;
+}
+/**
+ * Schema builder namespace.
+ */
+declare const t: {
+  /** Represents the `number` type. */
+  number: () => TypeSchema;
+  /** Represents the `string` type. */
+  string: () => TypeSchema;
+  /** Represents the `boolean` type. */
+  boolean: () => TypeSchema;
+  /** Represents the `void` type. */
+  void: () => TypeSchema;
+  /** Represents the `undefined` type. */
+  undefined: () => TypeSchema;
+  /** Represents the `null` type. */
+  null: () => TypeSchema;
+  /**
+   * Represents the `any` type. Useful as a placeholder in object schemas when
+   * you care about a property's existence but not its type.
+   */
+  any: () => TypeSchema;
+  /**
+   * Represents the `unknown` type. Semantically identical to `t.any()` as a
+   * predicate, but communicates intent differently in your schema.
+   */
+  unknown: () => TypeSchema;
+  /**
+   * Represents an object type with the specified shape. Each property must be
+   * present and non-optional unless its schema was marked `.optional()`.
+   *
+   * Extra properties are allowed (structural subtyping), consistent with
+   * TypeScript's own assignability rules.
+   *
+   * @example
+   * ```typescript
+   * const Point = t.object({
+   *   x: t.number(),
+   *   y: t.number(),
+   *   label: t.string().optional(),
+   * });
+   * ```
+   */
+  object: (shape: Record<string, TypeSchema>) => TypeSchema;
+  /**
+   * Represents an array type whose element type satisfies the given schema.
+   * Checks for a numeric index signature, so it also covers tuples and other
+   * numerically-indexed types.
+   *
+   * @example
+   * ```typescript
+   * const NumberArray = t.array(t.number());
+   * ```
+   */
+  array: (element: TypeSchema) => TypeSchema;
+  /**
+   * Represents a union of the given schemas. For union source types, every
+   * constituent must individually satisfy at least one member schema.
+   *
+   * @example
+   * ```typescript
+   * const StringOrNumber = t.union(t.string(), t.number());
+   * ```
+   */
+  union: (...members: TypeSchema[]) => TypeSchema;
+  /**
+   * Represents an intersection of the given schemas. The type must satisfy
+   * every member schema simultaneously.
+   *
+   * @example
+   * ```typescript
+   * const NamedAndAged = t.intersection(
+   *   t.object({ name: t.string() }),
+   *   t.object({ age: t.number() }),
+   * );
+   * ```
+   */
+  intersection: (...members: TypeSchema[]) => TypeSchema;
+  /**
+   * Represents a type exported from a module in the program. Resolves a genuine
+   * `ts.Type` and delegates to `checker.isTypeAssignableTo()`, so it handles
+   * nominal class hierarchies correctly.
+   *
+   * Resolved types are cached per `TypeChecker` instance (via a `WeakMap`) so
+   * repeated calls across files do not re-scan source files.
+   *
+   * Requires `program` in the {@link SchemaContext}.
+   *
+   * @param modulePathPattern Substring matched against source-file paths.
+   * @param exportName The exported type, class or interface name.
+   *
+   * @example
+   * ```typescript
+   * const BaseWindow = t.fromModule("/electron/", "BaseWindow");
+   * const Buffer = t.fromModule("@types/node", "Buffer");
+   * ```
+   */
+  fromModule: (modulePathPattern: string, exportName: string) => TypeSchema;
+  /**
+   * Escape hatch for arbitrary predicates that the DSL cannot express directly.
+   *
+   * @example
+   * ```typescript
+   * const HasLengthProp = t.custom((type) =>
+   *   type.getProperty("length") != null,
+   * );
+   * ```
+   */
+  custom: (predicate: AcceptsFn) => TypeSchema;
+};
+/**
+ * Returns `true` if the given TypeScript type is assignable to the schema–in
+ * other words, if `type extends T` with `T` the TypeScript type represented
+ * by the schema.
+ */
+declare function isAssignableTo(ctx: SchemaContext, type: Type, schema: TypeSchema): boolean;
+//#endregion
+export { SchemaContext, TypeSchema, isAssignableTo, t };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;AAQA;;AACW,KADC,aAAA,GACD;EAAW,OACV,EADD,WACC;EAAO,OAAA,CAAA,EAAP,OAAO;AACjB,CAAA;KAEG,SAAA,GAAS,CAAA,IAAA,EAAU,IAAV,EAAA,GAAA,EAAqB,aAArB,EAAA,GAAA,OAAA;;;AAAkC;AAQhD;;;AAQuB,cARV,UAAA,CAQU;EAAS;EAiBR,SAYV,QAAA,EAnCO,SAmCP;EAAU;EAYD,SAAA,WAAA,EAAA,OAAA;EAaV;EA+MZ,WAAA,CAAA,OAAA,EArQsB,SAqQtB,EAAA,UAAA,CAAA,EAAA,OAAA;EAAA;;;;;;;;;;;;EAjH4B,QAAG,CAAA,CAAA,EAnIlB,UAmIkB;EAAU;;;;;;;AAgHE;EAQ5B,QAAA,CAAA,CAAA,EA/OF,UA+OgB;EAAA;;;;AAGV;;;;aAtOP;;;;;cAaA;;gBAEC;;gBAMA;;iBAMC;;cAMH;;mBAMK;;cAML;;;;;aASD;;;;;iBAMI;;;;;;;;;;;;;;;;;kBAkBG,eAAe,gBAAc;;;;;;;;;;;mBA6B5B,eAAa;;;;;;;;;;sBAgBV,iBAAe;;;;;;;;;;;;;6BAsBR,iBAAe;;;;;;;;;;;;;;;;;;;;iEAsBmB;;;;;;;;;;;sBAoDzC,cAAY;;;;;;;iBAQlB,cAAA,MACT,qBACC,cACE"}

package/dist/index.js

@@ -0,0 +1,127 @@
+//#region src/index.ts
+const TS_SYMBOL_FLAGS_OPTIONAL = 16777216;
+/**
+* A type schema that checks whether a TypeScript compiler type is assignable
+* to the type represented by the schema.
+*
+* Obtain instances through the {@link t} builder, never instantiate directly.
+*/
+var TypeSchema = class TypeSchema {
+	/** @internal */
+	_accepts;
+	/** @internal */
+	_isOptional;
+	/** @internal */
+	constructor(accepts, isOptional = false) {
+		this._accepts = accepts;
+		this._isOptional = isOptional;
+	}
+	/**
+	* Marks this schema as optional when used as a property in {@link t.object}.
+	* An optional property may be absent from the type or carry the TypeScript
+	* `Optional` symbol flag.
+	*
+	* @example
+	* ```typescript
+	* const Shape = t.object({
+	*   label: t.string().optional(),
+	* });
+	* ```
+	*/
+	optional() {
+		return new TypeSchema(t.union(this, t.undefined())._accepts, true);
+	}
+	/**
+	* Wraps this schema to also accept `null`.
+	*
+	* @example
+	* ```typescript
+	* const MaybeNumber = t.number().nullable(); // number | null
+	* ```
+	*/
+	nullable() {
+		return t.union(this, t.null());
+	}
+	/**
+	* Wraps this schema to also accept `null` and `undefined`.
+	*
+	* @example
+	* ```typescript
+	* const MaybeNumber = t.number().nullish(); // number | null | undefined
+	* ```
+	*/
+	nullish() {
+		return this.nullable().optional();
+	}
+};
+const schema = (check) => new TypeSchema(check);
+const moduleTypeCache = new WeakMap();
+/**
+* Schema builder namespace.
+*/
+const t = {
+	number: () => schema((type, { checker }) => checker.isTypeAssignableTo(type, checker.getNumberType())),
+	string: () => schema((type, { checker }) => checker.isTypeAssignableTo(type, checker.getStringType())),
+	boolean: () => schema((type, { checker }) => checker.isTypeAssignableTo(type, checker.getBooleanType())),
+	void: () => schema((type, { checker }) => checker.isTypeAssignableTo(type, checker.getVoidType())),
+	undefined: () => schema((type, { checker }) => checker.isTypeAssignableTo(type, checker.getUndefinedType())),
+	null: () => schema((type, { checker }) => checker.isTypeAssignableTo(type, checker.getNullType())),
+	any: () => schema(() => true),
+	unknown: () => schema(() => true),
+	object: (shape) => schema((type, ctx) => Object.entries(shape).every(([key, propSchema]) => {
+		const propSymbol = type.getProperty(key);
+		if (!propSymbol) return propSchema._isOptional;
+		if (!propSchema._isOptional && (propSymbol.flags & TS_SYMBOL_FLAGS_OPTIONAL) !== 0) return false;
+		const propType = ctx.checker.getTypeOfSymbol(propSymbol);
+		return propSchema._accepts(propType, ctx);
+	})),
+	array: (element) => schema((type, ctx) => {
+		const indexType = type.getNumberIndexType();
+		if (!indexType) return false;
+		return element._accepts(indexType, ctx);
+	}),
+	union: (...members) => schema((type, ctx) => {
+		if (type.isUnion()) return type.types.every((member) => members.some((m) => m._accepts(member, ctx)));
+		return members.some((m) => m._accepts(type, ctx));
+	}),
+	intersection: (...members) => schema((type, ctx) => members.every((m) => m._accepts(type, ctx))),
+	fromModule: (modulePathPattern, exportName) => schema((type, { checker, program }) => {
+		if (!program) throw new Error("t.fromModule() requires `program` in the SchemaContext.");
+		let cache = moduleTypeCache.get(checker);
+		if (!cache) {
+			cache = new Map();
+			moduleTypeCache.set(checker, cache);
+		}
+		const cacheKey = JSON.stringify([modulePathPattern, exportName]);
+		if (!cache.has(cacheKey)) {
+			let resolved = null;
+			for (const sourceFile of program.getSourceFiles()) {
+				if (!sourceFile.fileName.includes(modulePathPattern)) continue;
+				const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+				if (!moduleSymbol) continue;
+				const exportSymbol = checker.getExportsOfModule(moduleSymbol).find((s) => s.getName() === exportName);
+				if (exportSymbol) {
+					resolved = checker.getDeclaredTypeOfSymbol(exportSymbol);
+					break;
+				}
+			}
+			cache.set(cacheKey, resolved);
+		}
+		const targetType = cache.get(cacheKey);
+		if (targetType == null) throw new Error(`t.fromModule(): could not resolve export "${exportName}" from any module matching "${modulePathPattern}".`);
+		return checker.isTypeAssignableTo(type, targetType);
+	}),
+	custom: (predicate) => schema(predicate)
+};
+/**
+* Returns `true` if the given TypeScript type is assignable to the schema–in
+* other words, if `type extends T` with `T` the TypeScript type represented
+* by the schema.
+*/
+function isAssignableTo(ctx, type, schema$1) {
+	return schema$1._accepts(type, ctx);
+}
+
+//#endregion
+export { TypeSchema, isAssignableTo, t };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["accepts: AcceptsFn","check: AcceptsFn","shape: Record<string, TypeSchema>","element: TypeSchema","modulePathPattern: string","exportName: string","resolved: Type | null","predicate: AcceptsFn","ctx: SchemaContext","type: Type","schema: TypeSchema"],"sources":["../src/index.ts"],"sourcesContent":["import type { TypeChecker, Type, Program, SymbolFlags } from \"typescript\";\n\nconst TS_SYMBOL_FLAGS_OPTIONAL = 16777216 satisfies SymbolFlags.Optional;\n\n/**\n * Context required by all schema checks. The `program` field is only needed\n * for schemas that resolve types from external modules ({@link t.fromModule}).\n */\nexport type SchemaContext = {\n  checker: TypeChecker;\n  program?: Program;\n};\n\ntype AcceptsFn = (type: Type, ctx: SchemaContext) => boolean;\n\n/**\n * A type schema that checks whether a TypeScript compiler type is assignable\n * to the type represented by the schema.\n *\n * Obtain instances through the {@link t} builder, never instantiate directly.\n */\nexport class TypeSchema {\n  /** @internal */\n  readonly _accepts: AcceptsFn;\n\n  /** @internal */\n  readonly _isOptional: boolean;\n\n  /** @internal */\n  constructor(accepts: AcceptsFn, isOptional = false) {\n    this._accepts = accepts;\n    this._isOptional = isOptional;\n  }\n\n  /**\n   * Marks this schema as optional when used as a property in {@link t.object}.\n   * An optional property may be absent from the type or carry the TypeScript\n   * `Optional` symbol flag.\n   *\n   * @example\n   * ```typescript\n   * const Shape = t.object({\n   *   label: t.string().optional(),\n   * });\n   * ```\n   */\n  optional(): TypeSchema {\n    return new TypeSchema(t.union(this, t.undefined())._accepts, true);\n  }\n\n  /**\n   * Wraps this schema to also accept `null`.\n   *\n   * @example\n   * ```typescript\n   * const MaybeNumber = t.number().nullable(); // number | null\n   * ```\n   */\n  nullable(): TypeSchema {\n    return t.union(this, t.null());\n  }\n\n  /**\n   * Wraps this schema to also accept `null` and `undefined`.\n   *\n   * @example\n   * ```typescript\n   * const MaybeNumber = t.number().nullish(); // number | null | undefined\n   * ```\n   */\n  nullish(): TypeSchema {\n    return this.nullable().optional();\n  }\n}\n\nconst schema = (check: AcceptsFn): TypeSchema => new TypeSchema(check);\n\n// Per-checker cache for `t.fromModule()` resolved types.\nconst moduleTypeCache = new WeakMap<TypeChecker, Map<string, Type | null>>();\n\n/**\n * Schema builder namespace.\n */\nexport const t = {\n  /** Represents the `number` type. */\n  number: (): TypeSchema =>\n    schema((type, { checker }) =>\n      checker.isTypeAssignableTo(type, checker.getNumberType())\n    ),\n\n  /** Represents the `string` type. */\n  string: (): TypeSchema =>\n    schema((type, { checker }) =>\n      checker.isTypeAssignableTo(type, checker.getStringType())\n    ),\n\n  /** Represents the `boolean` type. */\n  boolean: (): TypeSchema =>\n    schema((type, { checker }) =>\n      checker.isTypeAssignableTo(type, checker.getBooleanType())\n    ),\n\n  /** Represents the `void` type. */\n  void: (): TypeSchema =>\n    schema((type, { checker }) =>\n      checker.isTypeAssignableTo(type, checker.getVoidType())\n    ),\n\n  /** Represents the `undefined` type. */\n  undefined: (): TypeSchema =>\n    schema((type, { checker }) =>\n      checker.isTypeAssignableTo(type, checker.getUndefinedType())\n    ),\n\n  /** Represents the `null` type. */\n  null: (): TypeSchema =>\n    schema((type, { checker }) =>\n      checker.isTypeAssignableTo(type, checker.getNullType())\n    ),\n\n  /**\n   * Represents the `any` type. Useful as a placeholder in object schemas when\n   * you care about a property's existence but not its type.\n   */\n  any: (): TypeSchema => schema(() => true),\n\n  /**\n   * Represents the `unknown` type. Semantically identical to `t.any()` as a\n   * predicate, but communicates intent differently in your schema.\n   */\n  unknown: (): TypeSchema => schema(() => true),\n\n  /**\n   * Represents an object type with the specified shape. Each property must be\n   * present and non-optional unless its schema was marked `.optional()`.\n   *\n   * Extra properties are allowed (structural subtyping), consistent with\n   * TypeScript's own assignability rules.\n   *\n   * @example\n   * ```typescript\n   * const Point = t.object({\n   *   x: t.number(),\n   *   y: t.number(),\n   *   label: t.string().optional(),\n   * });\n   * ```\n   */\n  object: (shape: Record<string, TypeSchema>): TypeSchema =>\n    schema((type, ctx) =>\n      Object.entries(shape).every(([key, propSchema]) => {\n        const propSymbol = type.getProperty(key);\n\n        if (!propSymbol) return propSchema._isOptional;\n\n        if (\n          !propSchema._isOptional &&\n          (propSymbol.flags & TS_SYMBOL_FLAGS_OPTIONAL) !== 0\n        ) {\n          return false;\n        }\n\n        const propType = ctx.checker.getTypeOfSymbol(propSymbol);\n        return propSchema._accepts(propType, ctx);\n      })\n    ),\n\n  /**\n   * Represents an array type whose element type satisfies the given schema.\n   * Checks for a numeric index signature, so it also covers tuples and other\n   * numerically-indexed types.\n   *\n   * @example\n   * ```typescript\n   * const NumberArray = t.array(t.number());\n   * ```\n   */\n  array: (element: TypeSchema): TypeSchema =>\n    schema((type, ctx) => {\n      const indexType = type.getNumberIndexType();\n      if (!indexType) return false;\n      return element._accepts(indexType, ctx);\n    }),\n\n  /**\n   * Represents a union of the given schemas. For union source types, every\n   * constituent must individually satisfy at least one member schema.\n   *\n   * @example\n   * ```typescript\n   * const StringOrNumber = t.union(t.string(), t.number());\n   * ```\n   */\n  union: (...members: TypeSchema[]): TypeSchema =>\n    schema((type, ctx) => {\n      if (type.isUnion()) {\n        return type.types.every((member) =>\n          members.some((m) => m._accepts(member, ctx))\n        );\n      }\n      return members.some((m) => m._accepts(type, ctx));\n    }),\n\n  /**\n   * Represents an intersection of the given schemas. The type must satisfy\n   * every member schema simultaneously.\n   *\n   * @example\n   * ```typescript\n   * const NamedAndAged = t.intersection(\n   *   t.object({ name: t.string() }),\n   *   t.object({ age: t.number() }),\n   * );\n   * ```\n   */\n  intersection: (...members: TypeSchema[]): TypeSchema =>\n    schema((type, ctx) => members.every((m) => m._accepts(type, ctx))),\n\n  /**\n   * Represents a type exported from a module in the program. Resolves a genuine\n   * `ts.Type` and delegates to `checker.isTypeAssignableTo()`, so it handles\n   * nominal class hierarchies correctly.\n   *\n   * Resolved types are cached per `TypeChecker` instance (via a `WeakMap`) so\n   * repeated calls across files do not re-scan source files.\n   *\n   * Requires `program` in the {@link SchemaContext}.\n   *\n   * @param modulePathPattern Substring matched against source-file paths.\n   * @param exportName The exported type, class or interface name.\n   *\n   * @example\n   * ```typescript\n   * const BaseWindow = t.fromModule(\"/electron/\", \"BaseWindow\");\n   * const Buffer = t.fromModule(\"@types/node\", \"Buffer\");\n   * ```\n   */\n  fromModule: (modulePathPattern: string, exportName: string): TypeSchema =>\n    schema((type, { checker, program }) => {\n      if (!program) {\n        throw new Error(\n          \"t.fromModule() requires `program` in the SchemaContext.\"\n        );\n      }\n\n      let cache = moduleTypeCache.get(checker);\n      if (!cache) {\n        cache = new Map();\n        moduleTypeCache.set(checker, cache);\n      }\n\n      const cacheKey = JSON.stringify([modulePathPattern, exportName]);\n\n      if (!cache.has(cacheKey)) {\n        let resolved: Type | null = null;\n        for (const sourceFile of program.getSourceFiles()) {\n          if (!sourceFile.fileName.includes(modulePathPattern)) continue;\n          const moduleSymbol = checker.getSymbolAtLocation(sourceFile);\n          if (!moduleSymbol) continue;\n          const exportSymbol = checker\n            .getExportsOfModule(moduleSymbol)\n            .find((s) => s.getName() === exportName);\n          if (exportSymbol) {\n            resolved = checker.getDeclaredTypeOfSymbol(exportSymbol);\n            break;\n          }\n        }\n        cache.set(cacheKey, resolved);\n      }\n\n      const targetType = cache.get(cacheKey);\n      if (targetType == null) {\n        throw new Error(\n          `t.fromModule(): could not resolve export \"${exportName}\" from any module matching \"${modulePathPattern}\".`\n        );\n      }\n      return checker.isTypeAssignableTo(type, targetType);\n    }),\n\n  /**\n   * Escape hatch for arbitrary predicates that the DSL cannot express directly.\n   *\n   * @example\n   * ```typescript\n   * const HasLengthProp = t.custom((type) =>\n   *   type.getProperty(\"length\") != null,\n   * );\n   * ```\n   */\n  custom: (predicate: AcceptsFn): TypeSchema => schema(predicate),\n};\n\n/**\n * Returns `true` if the given TypeScript type is assignable to the schema–in\n * other words, if `type extends T` with `T` the TypeScript type represented\n * by the schema.\n */\nexport function isAssignableTo(\n  ctx: SchemaContext,\n  type: Type,\n  schema: TypeSchema\n): boolean {\n  return schema._accepts(type, ctx);\n}\n"],"mappings":";AAEA,MAAM,2BAA2B;;;;;;;AAmBjC,IAAa,aAAb,MAAa,WAAW;;CAEtB,AAAS;;CAGT,AAAS;;CAGT,YAAYA,SAAoB,aAAa,OAAO;AAClD,OAAK,WAAW;AAChB,OAAK,cAAc;CACpB;;;;;;;;;;;;;CAcD,WAAuB;AACrB,SAAO,IAAI,WAAW,EAAE,MAAM,MAAM,EAAE,WAAW,CAAC,CAAC,UAAU;CAC9D;;;;;;;;;CAUD,WAAuB;AACrB,SAAO,EAAE,MAAM,MAAM,EAAE,MAAM,CAAC;CAC/B;;;;;;;;;CAUD,UAAsB;AACpB,SAAO,KAAK,UAAU,CAAC,UAAU;CAClC;AACF;AAED,MAAM,SAAS,CAACC,UAAiC,IAAI,WAAW;AAGhE,MAAM,kBAAkB,IAAI;;;;AAK5B,MAAa,IAAI;CAEf,QAAQ,MACN,OAAO,CAAC,MAAM,EAAE,SAAS,KACvB,QAAQ,mBAAmB,MAAM,QAAQ,eAAe,CAAC,CAC1D;CAGH,QAAQ,MACN,OAAO,CAAC,MAAM,EAAE,SAAS,KACvB,QAAQ,mBAAmB,MAAM,QAAQ,eAAe,CAAC,CAC1D;CAGH,SAAS,MACP,OAAO,CAAC,MAAM,EAAE,SAAS,KACvB,QAAQ,mBAAmB,MAAM,QAAQ,gBAAgB,CAAC,CAC3D;CAGH,MAAM,MACJ,OAAO,CAAC,MAAM,EAAE,SAAS,KACvB,QAAQ,mBAAmB,MAAM,QAAQ,aAAa,CAAC,CACxD;CAGH,WAAW,MACT,OAAO,CAAC,MAAM,EAAE,SAAS,KACvB,QAAQ,mBAAmB,MAAM,QAAQ,kBAAkB,CAAC,CAC7D;CAGH,MAAM,MACJ,OAAO,CAAC,MAAM,EAAE,SAAS,KACvB,QAAQ,mBAAmB,MAAM,QAAQ,aAAa,CAAC,CACxD;CAMH,KAAK,MAAkB,OAAO,MAAM,KAAK;CAMzC,SAAS,MAAkB,OAAO,MAAM,KAAK;CAkB7C,QAAQ,CAACC,UACP,OAAO,CAAC,MAAM,QACZ,OAAO,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,WAAW,KAAK;EACjD,MAAM,aAAa,KAAK,YAAY,IAAI;AAExC,OAAK,WAAY,QAAO,WAAW;AAEnC,OACG,WAAW,gBACX,WAAW,QAAQ,8BAA8B,EAElD,QAAO;EAGT,MAAM,WAAW,IAAI,QAAQ,gBAAgB,WAAW;AACxD,SAAO,WAAW,SAAS,UAAU,IAAI;CAC1C,EAAC,CACH;CAYH,OAAO,CAACC,YACN,OAAO,CAAC,MAAM,QAAQ;EACpB,MAAM,YAAY,KAAK,oBAAoB;AAC3C,OAAK,UAAW,QAAO;AACvB,SAAO,QAAQ,SAAS,WAAW,IAAI;CACxC,EAAC;CAWJ,OAAO,CAAC,GAAG,YACT,OAAO,CAAC,MAAM,QAAQ;AACpB,MAAI,KAAK,SAAS,CAChB,QAAO,KAAK,MAAM,MAAM,CAAC,WACvB,QAAQ,KAAK,CAAC,MAAM,EAAE,SAAS,QAAQ,IAAI,CAAC,CAC7C;AAEH,SAAO,QAAQ,KAAK,CAAC,MAAM,EAAE,SAAS,MAAM,IAAI,CAAC;CAClD,EAAC;CAcJ,cAAc,CAAC,GAAG,YAChB,OAAO,CAAC,MAAM,QAAQ,QAAQ,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,IAAI,CAAC,CAAC;CAqBpE,YAAY,CAACC,mBAA2BC,eACtC,OAAO,CAAC,MAAM,EAAE,SAAS,SAAS,KAAK;AACrC,OAAK,QACH,OAAM,IAAI,MACR;EAIJ,IAAI,QAAQ,gBAAgB,IAAI,QAAQ;AACxC,OAAK,OAAO;AACV,WAAQ,IAAI;AACZ,mBAAgB,IAAI,SAAS,MAAM;EACpC;EAED,MAAM,WAAW,KAAK,UAAU,CAAC,mBAAmB,UAAW,EAAC;AAEhE,OAAK,MAAM,IAAI,SAAS,EAAE;GACxB,IAAIC,WAAwB;AAC5B,QAAK,MAAM,cAAc,QAAQ,gBAAgB,EAAE;AACjD,SAAK,WAAW,SAAS,SAAS,kBAAkB,CAAE;IACtD,MAAM,eAAe,QAAQ,oBAAoB,WAAW;AAC5D,SAAK,aAAc;IACnB,MAAM,eAAe,QAClB,mBAAmB,aAAa,CAChC,KAAK,CAAC,MAAM,EAAE,SAAS,KAAK,WAAW;AAC1C,QAAI,cAAc;AAChB,gBAAW,QAAQ,wBAAwB,aAAa;AACxD;IACD;GACF;AACD,SAAM,IAAI,UAAU,SAAS;EAC9B;EAED,MAAM,aAAa,MAAM,IAAI,SAAS;AACtC,MAAI,cAAc,KAChB,OAAM,IAAI,OACP,4CAA4C,WAAW,8BAA8B,kBAAkB;AAG5G,SAAO,QAAQ,mBAAmB,MAAM,WAAW;CACpD,EAAC;CAYJ,QAAQ,CAACC,cAAqC,OAAO,UAAU;AAChE;;;;;;AAOD,SAAgB,eACdC,KACAC,MACAC,UACS;AACT,QAAO,SAAO,SAAS,MAAM,IAAI;AAClC"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@liautaud/typezod",
+  "version": "1.0.0",
+  "description": "Zod-like DSL for comparing TypeScript compiler types against user-defined schemas",
+  "type": "module",
+  "license": "MIT",
+  "author": "Romain Liautaud",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/liautaud/typezod.git"
+  },
+  "keywords": [
+    "typescript",
+    "type-checking",
+    "type-aware-linting",
+    "typescript-eslint",
+    "zod"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm test && npm run build"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "devDependencies": {
+    "tsdown": "^0.11.9",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}