typia

Typia

 // RUNTIME VALIDATORS
export function is < T > ( input : unknown ) : input is T ; // returns boolean
export function assert < T > ( input : unknown ) : T ; // throws TypeGuardError
export function assertGuard < T > ( input : unknown ) : asserts input is T ;
export function validate < T > ( input : unknown ) : IValidation < T > ; // detailed

// JSON FUNCTIONS
export namespace json {
  export function application < T > ( ) : IJsonApplication ; // JSON schema
  export function assertParse < T > ( input : string ) : T ; // type safe parser
  export function assertStringify < T > ( input : T ) : string ; // safe and faster
}

// LLM FUNCTION CALLING SCHEMA
export namespace llm {
  // application schema from a class or interface type
  export function application < App , Model > ( ) : ILlmApplication < Model > ;
  // structured output
  export function parameters < P , Moodel > ( ) : ILlmSchema . IParameters < Model > ; 
  export function schema < T , Model > ( ) : ILlmSchema < Model > ; // type schema
}

// PROTOCOL BUFFER
export namespace protobuf {
  export function message < T > ( ) : string ; // Protocol Buffer message
  export function assertDecode < T > ( buffer : Uint8Array ) : T ; // safe decoder
  export function assertEncode < T > ( input : T ) : Uint8Array ; // safe encoder
}

// RANDOM GENERATOR
export function random < T > ( g ?: Partial < IRandomGenerator > ) : T ;

typia est une bibliothèque de transformateurs prenant en charge les fonctionnalités ci-dessous:

• Validateurs d'exécution super rapides
• Schéma JSON amélioré et SERDE
• Fonction LLM appelant le schéma et la sortie structurée
• Encodeur et décodeur de tampon de protocole
• Générateur de données aléatoire

Note

• Une seule ligne requise, avec un type de type pur
• Le validateur d'exécution est 20 000x plus rapide que class-validator
• La sérialisation JSON est 200X plus rapide que class-transformer

Transformation

Si vous appelez la fonction typia , elle serait compilée comme ci-dessous.

Il s'agit du concept clé de typia , transformant le type de typeScript en une fonction d'exécution. La fonction typia.is<T>() est transformée en un vérificateur de type dédié en analysant le type cible T au niveau de compilation.

Cette fonctionnalité permet aux développeurs d'assurer la sécurité des types dans leurs applications, en tirant parti du typage statique de TypeScript tout en fournissant la validation d'exécution. Au lieu de définir des schémas supplémentaires, vous pouvez simplement utiliser le type de type TypeScript pur lui-même.

 //----
// examples/checkString.ts
//----
import typia , { tags } from "typia" ;
export const checkString = typia . createIs < string > ( ) ;

//----
// examples/checkUUID.js
//----
import typia from "typia" ;
export const checkString = ( ( ) => {
  return ( input ) => "string" === typeof input ;
} ) ( ) ; 

Sponsors

Merci pour votre soutien.

Votre don encourage le développement typia .

De plus, typia redistribue la moitié des dons aux principaux contributeurs de typia .

• nonara/ts-patch
• ryoppippi/unplugin-typia

Aire de jeux

Vous pouvez découvrir le fonctionnement de Typia par le site Web de Playground:

• https://typia.io/playground

Guider des documents

Consultez le document dans le site Web:

? Maison

• Introduction
• Installation
• Pur dactypre

Caractéristiques

• Validateurs d'exécution
  • Fonction assert()
  • is() fonction
  • validate() Fonction
  • Module fonctionnel
  • Tags spéciaux
• JSON amélioré
  • Schéma JSON
  • fonctions stringify()
  • Fonctions parse()
• Fonction LLM Appel
  • Fonction application()
  • Fonction parameters()
  • schema() Fonction
  • Stratégie de documentation
• Tampon de protocole
  • Schéma de messages
  • fonctions decode()
  • Fonctions encode()
• Générateur aléatoire
• Divers

? Appendice

• Documents API
• Cas d'utilisation
  • Nichés
  • Prisma
  • trpc
• ⇲ Résultat de référence
• ⇲ Articles dev.to