@liautaud/typezod 1.0.0 → 1.0.1

package/dist/{index.d.ts → index.d.mts}

@@ -172,5 +172,4 @@ declare const t: {
  */
 declare function isAssignableTo(ctx: SchemaContext, type: Type, schema: TypeSchema): boolean;
 //#endregion
-export { SchemaContext, TypeSchema, isAssignableTo, t };
-//# sourceMappingURL=index.d.ts.map
+export { SchemaContext, TypeSchema, isAssignableTo, t };

package/dist/{index.js → index.mjs}

@@ -55,7 +55,7 @@ var TypeSchema = class TypeSchema {
 	}
 };
 const schema = (check) => new TypeSchema(check);
-const moduleTypeCache = new WeakMap();
+const moduleTypeCache = /* @__PURE__ */ new WeakMap();
 /**
 * Schema builder namespace.
 */
@@ -89,7 +89,7 @@ const t = {
 		if (!program) throw new Error("t.fromModule() requires `program` in the SchemaContext.");
 		let cache = moduleTypeCache.get(checker);
 		if (!cache) {
-			cache = new Map();
+			cache = /* @__PURE__ */ new Map();
 			moduleTypeCache.set(checker, cache);
 		}
 		const cacheKey = JSON.stringify([modulePathPattern, exportName]);
@@ -123,5 +123,4 @@ function isAssignableTo(ctx, type, schema$1) {
 }
 
 //#endregion
-export { TypeSchema, isAssignableTo, t };
-//# sourceMappingURL=index.js.map
+export { TypeSchema, isAssignableTo, t };

package/package.json

@@ -1,14 +1,18 @@
 {
   "name": "@liautaud/typezod",
-  "version": "1.0.0",
-  "description": "Zod-like DSL for comparing TypeScript compiler types against user-defined schemas",
   "type": "module",
-  "license": "MIT",
+  "version": "1.0.1",
+  "description": "Zod-like DSL for comparing TypeScript compiler types against user-defined schemas",
   "author": "Romain Liautaud",
+  "license": "MIT",
+  "homepage": "https://github.com/liautaud/typezod#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/liautaud/typezod.git"
   },
+  "bugs": {
+    "url": "https://github.com/liautaud/typezod/issues"
+  },
   "keywords": [
     "typescript",
     "type-checking",
@@ -32,16 +36,19 @@
   },
   "scripts": {
     "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run",
     "prepublishOnly": "npm test && npm run build"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"
   },
   "devDependencies": {
-    "tsdown": "^0.11.9",
+    "@types/node": "^25.0.3",
+    "prettier": "^3.8.1",
+    "tsdown": "^0.18.1",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.16"
   }
 }

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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":"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"}