or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

built-in-validators.mddata-transformation.mderror-handling.mdgeneric-types.mdindex.mdscope-modules.mdstring-processing.mdtype-creation.md
tile.json

string-processing.mddocs/

String Processing

Advanced string validation, transformation, and parsing capabilities including formats, morphs, and data conversion.

Capabilities

String Transformation Morphs

Data transformations that convert input strings to modified output strings.

const string: {
  /** Trim whitespace from start and end */
  trim: {
    root: Type<(In: string) => To<string>>;
    preformatted: Type<string>; // Already trimmed strings
  };
  
  /** Convert to lowercase */
  lower: {
    root: Type<(In: string) => To<string>>;
    preformatted: Type<string>; // Already lowercase strings
  };
  
  /** Convert to uppercase */
  upper: {
    root: Type<(In: string) => To<string>>;
    preformatted: Type<string>; // Already uppercase strings
  };
  
  /** Capitalize first letter */
  capitalize: {
    root: Type<(In: string) => To<string>>;
    preformatted: Type<string>; // Already capitalized strings
  };
  
  /** Unicode normalization */
  normalize: {
    root: Type<(In: string) => To<string>>; // NFC normalization
    NFC: Type<(In: string) => To<string>>;
    NFD: Type<(In: string) => To<string>>;
    NFKC: Type<(In: string) => To<string>>;
    NFKD: Type<(In: string) => To<string>>;
  };
};

Usage Examples:

// String cleanup
const CleanInput = type("string.trim");
const result = CleanInput("  hello world  "); // "hello world"

// Case conversion  
const LowerName = type("string.lower");
const UpperCode = type("string.upper");
const TitleCase = type("string.capitalize");

// In object processing
const UserInput = type({
  name: "string.trim.capitalize",
  email: "string.trim.lower",
  code: "string.upper"
});

// Normalization for international text
const NormalizedText = type("string.normalize.NFC");

Numeric String Parsing

String-to-number conversion with validation.

const string: {
  /** Well-formed numeric strings */
  numeric: {
    root: Type<string>; // Validates format
    parse: Type<(In: string) => To<number>>; // Parses to number
  };
  
  /** Well-formed integer strings */
  integer: {
    root: Type<string>; // Validates integer format
    parse: Type<(In: string) => To<number>>; // Parses to safe integer
  };
};

Usage Examples:

// Numeric validation and parsing
const NumericString = type("string.numeric");
NumericString("123.45"); // Valid: "123.45"
NumericString("not-a-number"); // Invalid

const ParseNumber = type("string.numeric.parse");
ParseNumber("123.45"); // Returns: 123.45 (number)

// Integer parsing
const ParseInt = type("string.integer.parse");
ParseInt("42"); // Returns: 42 (number)

// Form data processing
const FormData = type({
  age: "string.integer.parse",
  price: "string.numeric.parse",
  name: "string.trim"
});

const result = FormData({
  age: "25",
  price: "19.99", 
  name: "  John Doe  "
});
// Result: { age: 25, price: 19.99, name: "John Doe" }

Date String Processing

Date format validation and parsing.

const string: {
  date: {
    root: Type<string>; // Any parseable date string
    parse: Type<(In: string) => To<Date>>; // Parse to Date object
    
    /** ISO 8601 format (YYYY-MM-DDTHH:mm:ss.sssZ) */
    iso: {
      root: Type<string>;
      parse: Type<(In: string) => To<Date>>;
    };
    
    /** Unix timestamp strings */
    epoch: {
      root: Type<string>; // Integer string in valid timestamp range
      parse: Type<(In: string) => To<Date>>;
    };
  };
};

Usage Examples:

// General date parsing
const DateString = type("string.date");
DateString("2023-12-25"); // Valid
DateString("December 25, 2023"); // Valid
DateString("invalid date"); // Invalid

const ParseDate = type("string.date.parse");
ParseDate("2023-12-25"); // Returns: Date object

// ISO format
const IsoDate = type("string.date.iso");
IsoDate("2023-12-25T10:30:00.000Z"); // Valid
IsoDate("2023-12-25"); // Invalid (not ISO format)

// Unix timestamps
const EpochString = type("string.date.epoch");
EpochString("1703505000"); // Valid timestamp
const ParseEpoch = type("string.date.epoch.parse");
ParseEpoch("1703505000"); // Returns: Date object

// API response processing
const EventData = type({
  title: "string.trim",
  startDate: "string.date.iso.parse",
  endDate: "string.date.iso.parse",
  createdAt: "string.date.epoch.parse"
});

JSON String Processing

JSON validation and parsing capabilities.

const string: {
  json: {
    root: Type<string>; // Valid JSON string format
    parse: Type<(In: string) => To<Json>>; // Parse to JSON object
  };
};

// JSON object type (for reference)
const json: {
  root: Type<Json>; // JSON-serializable values
  stringify: Type<(In: Json) => To<string>>; // Stringify JSON
};

Usage Examples:

// JSON string validation
const JsonString = type("string.json");
JsonString('{"name": "John", "age": 30}'); // Valid
JsonString("not json"); // Invalid

// JSON parsing
const ParseJson = type("string.json.parse");
const result = ParseJson('{"name": "John", "age": 30}');
// Returns: { name: "John", age: 30 }

// API request processing
const ApiRequest = type({
  payload: "string.json.parse",
  timestamp: "string.date.iso"
});

// Bidirectional JSON processing
const JsonProcessor = type({
  data: "json", // Accept JSON object
  serialized: "string.json" // Validate JSON string
});

Format Validation

String format validators for common patterns.

const string: {
  /** Email address format */
  email: Type<string>;
  
  /** Valid URL format */
  url: {
    root: Type<string>;
    parse: Type<(In: string) => To<URL>>; // Parse to URL object
  };
  
  /** UUID format with version variants */
  uuid: {
    root: Type<string>; // Any valid UUID
    v1: Type<string>;   // UUID v1
    v2: Type<string>;   // UUID v2  
    v3: Type<string>;   // UUID v3
    v4: Type<string>;   // UUID v4
    v5: Type<string>;   // UUID v5
    v6: Type<string>;   // UUID v6
    v7: Type<string>;   // UUID v7
    v8: Type<string>;   // UUID v8
  };
  
  /** IP address format */
  ip: {
    root: Type<string>; // IPv4 or IPv6
    v4: Type<string>;   // IPv4 only
    v6: Type<string>;   // IPv6 only
  };
  
  /** Credit card number with Luhn validation */
  creditCard: Type<string>;
  
  /** Semantic version format */
  semver: Type<string>;
  
  /** Valid regex pattern */
  regex: Type<string>;
};

Usage Examples:

// Format validation
const UserProfile = type({
  email: "string.email",
  website: "string.url",
  id: "string.uuid.v4",
  ipAddress: "string.ip.v4"
});

// URL parsing
const ParseUrl = type("string.url.parse");
const urlObj = ParseUrl("https://example.com/path");
// Returns: URL object with host, pathname, etc.

// Specific UUID versions
const SessionId = type("string.uuid.v4");
const TraceId = type("string.uuid.v1");

// Network validation
const ServerConfig = type({
  host: "string.ip.v4",
  port: "number.integer > 0 <= 65535"
});

Encoding and Special Formats

Additional string format validators.

const string: {
  /** Base64 encoded strings */
  base64: {
    root: Type<string>;     // Standard base64
    url: Type<string>;      // Base64url encoding
  };
  
  /** Character set constraints */
  alpha: Type<string>;         // Letters only
  alphanumeric: Type<string>;  // Letters and digits
  digits: Type<string>;        // Digits only  
  hex: Type<string>;           // Hexadecimal characters
};

Usage Examples:

// Encoding validation
const EncodedData = type("string.base64");
const UrlSafeEncoded = type("string.base64.url");

// Character constraints
const Username = type("string.alphanumeric >= 3 <= 20");
const HexColor = type("string.hex");

// API key validation
const ApiKey = type("string.hex >= 32");
const Token = type("string.base64");

String Processing Patterns

Chained Transformations

Multiple string operations can be chained together.

// Multiple transformations
const ProcessName = type("string.trim.capitalize");
const result = ProcessName("  john doe  "); // "John doe"

// Complex processing pipeline
const CleanEmail = type("string.trim.lower");
const ProcessedUser = type({
  name: "string.trim.capitalize",
  email: "string.trim.lower",
  code: "string.trim.upper"
});

Validation with Transformation

Combine format validation with data transformation.

// Parse and validate
const ProcessAge = type("string.integer.parse >= 0 <= 120");
const age = ProcessAge("25"); // Returns: 25 (number)

// URL processing
const ProcessUrl = type("string.url.parse");
const url = ProcessUrl("https://example.com");
// Returns: URL object

// Date with constraints
const FutureDate = type("string.date.iso.parse > new Date()");