tjs-lang 0.6.19 → 0.6.26

package/dist/src/lang/linter.d.ts

@@ -1,53 +0,0 @@
-/**
- * TJS Linter
- *
- * Static analysis for TJS code:
- * - Unused variables
- * - Undefined variables
- * - Type mismatches (when __tjs metadata available)
- * - Unreachable code
- *
- * POC: Focus on variable usage first, then type checking.
- */
-export interface LintDiagnostic {
-    severity: 'error' | 'warning' | 'info';
-    message: string;
-    line?: number;
-    column?: number;
-    rule: string;
-}
-export interface LintResult {
-    diagnostics: LintDiagnostic[];
-    valid: boolean;
-}
-export interface LintOptions {
-    /** Check for unused variables */
-    unusedVariables?: boolean;
-    /** Check for undefined variables */
-    undefinedVariables?: boolean;
-    /** Check for unreachable code */
-    unreachableCode?: boolean;
-    /** Warn about explicit `new` keyword usage (TJS makes classes callable without new) */
-    noExplicitNew?: boolean;
-    /** Filename for error messages */
-    filename?: string;
-}
-/**
- * Lint TJS source code
- */
-export declare function lint(source: string, options?: LintOptions): LintResult;
-/**
- * Questions/Notes for future:
- *
- * Q1: Should we integrate with __tjs metadata for cross-file type checking?
- *     - Would need to load metadata from imported modules
- *     - Could check function call arguments against declared parameter types
- *
- * Q2: How strict should undefined variable checking be?
- *     - Currently relies on JS globals being available
- *     - Could have a whitelist of known globals (console, Math, etc.)
- *
- * Q3: Should linting be incremental / cacheable?
- *     - For large projects, re-linting everything is slow
- *     - Could hash files and skip unchanged ones
- */

package/dist/src/lang/metadata-cache.d.ts

@@ -1,172 +0,0 @@
-/**
- * IndexedDB-based cache for module metadata
- *
- * Caches transpilation results (AST, signatures, type info) to avoid
- * re-parsing unchanged source code. Particularly useful for:
- * - Playground editors (instant feedback on unchanged code)
- * - Autocomplete metadata retrieval
- * - Development workflows with rapid iteration
- *
- * @example
- * ```typescript
- * const cache = new MetadataCache()
- * await cache.open()
- *
- * // Check cache before transpiling
- * const cached = await cache.get(source)
- * if (cached) {
- *   return cached  // Skip transpilation
- * }
- *
- * // Transpile and cache
- * const result = transpile(source)
- * await cache.set(source, result)
- * ```
- */
-import type { SeqNode } from '../builder';
-import type { FunctionSignature, TranspileWarning } from './types';
-import type { TJSTypeInfo } from './emitters/js';
-/** Cached entry for AsyncJS transpilation (ajs/transpile) */
-export interface CachedTranspileResult {
-    ast: SeqNode;
-    signature: FunctionSignature;
-    warnings: TranspileWarning[];
-}
-/** Cached entry for TJS transpilation (tjs/transpileToJS) */
-export interface CachedTJSResult {
-    code: string;
-    types: Record<string, TJSTypeInfo>;
-    testRunner?: string;
-    testCount?: number;
-    warnings?: string[];
-}
-/** Full cache entry stored in IndexedDB */
-export interface CacheEntry {
-    /** SHA-256 hash of source + version */
-    hash: string;
-    /** TJS version used during transpilation */
-    version: string;
-    /** Timestamp when cached */
-    timestamp: number;
-    /** AsyncJS transpilation result */
-    transpile?: CachedTranspileResult;
-    /** TJS transpilation result */
-    tjs?: CachedTJSResult;
-}
-/** Cache statistics */
-export interface CacheStats {
-    /** Number of entries in cache */
-    entries: number;
-    /** Total bytes used (approximate) */
-    bytes: number;
-    /** Cache hit count this session */
-    hits: number;
-    /** Cache miss count this session */
-    misses: number;
-    /** Hit rate (hits / (hits + misses)) */
-    hitRate: number;
-}
-/**
- * Compute SHA-256 hash of source code + version
- * Falls back to simple hash if crypto.subtle unavailable
- */
-export declare function hashSource(source: string): Promise<string>;
-/**
- * Synchronous hash for environments without async support
- * Uses djb2 algorithm
- */
-export declare function hashSourceSync(source: string): string;
-/**
- * IndexedDB-based metadata cache
- *
- * Thread-safe and persistent across browser sessions.
- * Automatically handles versioning - entries from old TJS versions
- * are ignored (stale data won't cause issues).
- */
-export declare class MetadataCache {
-    private db;
-    private stats;
-    private pendingOpen;
-    /**
-     * Open the cache database
-     * Safe to call multiple times - will reuse existing connection
-     */
-    open(): Promise<void>;
-    private _open;
-    /**
-     * Get cached entry by source code
-     * Returns undefined if not cached or version mismatch
-     */
-    get(source: string): Promise<CacheEntry | undefined>;
-    /**
-     * Get cached transpile result (AsyncJS -> AST)
-     */
-    getTranspile(source: string): Promise<CachedTranspileResult | undefined>;
-    /**
-     * Get cached TJS result (TJS -> JS)
-     */
-    getTJS(source: string): Promise<CachedTJSResult | undefined>;
-    /**
-     * Store transpile result
-     */
-    setTranspile(source: string, result: CachedTranspileResult): Promise<void>;
-    /**
-     * Store TJS result
-     */
-    setTJS(source: string, result: CachedTJSResult): Promise<void>;
-    /**
-     * Store or update cache entry
-     */
-    private _set;
-    /**
-     * Delete a specific entry
-     */
-    delete(source: string): Promise<void>;
-    /**
-     * Clear all cached entries
-     */
-    clear(): Promise<void>;
-    /**
-     * Remove entries older than maxAge milliseconds
-     * Returns count of entries removed
-     */
-    prune(maxAge: number): Promise<number>;
-    /**
-     * Remove entries from old TJS versions
-     * Returns count of entries removed
-     */
-    pruneOldVersions(): Promise<number>;
-    /**
-     * Get cache statistics
-     */
-    getStats(): Promise<CacheStats>;
-    /**
-     * Count entries in cache
-     */
-    count(): Promise<number>;
-    /**
-     * Estimate storage size in bytes
-     */
-    estimateSize(): Promise<number>;
-    /**
-     * Close the database connection
-     */
-    close(): void;
-    /**
-     * Check if cache is available (IndexedDB accessible)
-     */
-    isAvailable(): boolean;
-    /**
-     * Reset session statistics
-     */
-    resetStats(): void;
-}
-/**
- * Get or create the global cache instance
- * Automatically opens the database on first call
- */
-export declare function getGlobalCache(): Promise<MetadataCache>;
-/**
- * Set a custom global cache instance (for testing)
- */
-export declare function setGlobalCache(cache: MetadataCache | null): void;

package/dist/src/lang/parser-params.d.ts

@@ -1,37 +0,0 @@
-/**
- * Parser parameter and annotation processing
- *
- * Handles the unified paren expression transformer that converts TJS syntax
- * (colon defaults, return type annotations, safe/unsafe markers) into valid JS.
- */
-export declare function transformParenExpressions(source: string, ctx: {
-    originalSource: string;
-    requiredParams: Set<string>;
-    unsafeFunctions: Set<string>;
-    safeFunctions: Set<string>;
-}): {
-    source: string;
-    returnType?: string;
-    returnSafety?: 'safe' | 'unsafe';
-};
-/**
- * Extract a JS value starting at a position in source.
- * Handles nested objects {}, arrays [], strings, numbers, booleans, null.
- * Uses state machine to properly track nesting.
- */
-export declare function extractJSValue(source: string, start: number): {
-    value: string;
-    endPos: number;
-} | null;
-/**
- * Preprocess source to handle custom syntax extensions
- *
- * Transforms:
- *   function foo(x: 'example') { }
- * Into:
- *   function foo(x = 'example') { }
- * And tracks that 'x' is a required parameter.
- *
- * Also handles return type annotation:
- *   function foo(x: 'example') -> { result: 'string' } { }
- */

package/dist/src/lang/parser-transforms.d.ts

@@ -1,281 +0,0 @@
-/**
- * Parser source transforms
- *
- * All source-to-source text transforms used by the preprocess pipeline.
- * These operate on raw source strings before Acorn parsing.
- */
-import type { WasmBlock, TestBlock } from './parser-types';
-export declare function transformTryWithoutCatch(source: string): string;
-/**
- * Extract WASM blocks from source and replace with runtime dispatch code
- *
- * Simple form (body used as both WASM source and JS fallback):
- *   wasm {
- *     for (let i = 0; i < arr.length; i++) { arr[i] *= 2 }
- *   }
- *
- * With explicit fallback (when you need different JS code):
- *   wasm {
- *     // WASM-optimized version
- *   } fallback {
- *     // Different JS implementation
- *   }
- *
- * Output:
- *   (globalThis.__tjs_wasm_0
- *     ? globalThis.__tjs_wasm_0(captures...)
- *     : (() => { body })())
- *
- * Variables are auto-captured from the body.
- */
-export declare function extractWasmBlocks(source: string): {
-    source: string;
-    blocks: WasmBlock[];
-};
-/**
- * Transform Is/IsNot infix operators to function calls
- *
- * Syntax:
- *   a Is b      -> Is(a, b)
- *   a IsNot b   -> IsNot(a, b)
- *
- * This enables structural equality with a clean syntax.
- */
-export declare function transformIsOperators(source: string): string;
-/**
- * Insert semicolons to prevent ASI footguns (TjsStandard mode)
- *
- * JavaScript's ASI (Automatic Semicolon Insertion) has notorious footguns:
- *
- *   foo          // Intended: call foo, then IIFE
- *   (() => {})() // Actual: foo(...)(...) - calls foo with IIFE as argument!
- *
- * TjsStandard prevents this by treating newlines as statement terminators
- * (like Go, Swift, Kotlin). When a line starts with a problematic character
- * that could continue the previous line, we insert a semicolon.
- *
- * Problematic line starts: ( [ / + - `
- *
- * We only insert when the previous line doesn't already end with:
- * - A semicolon
- * - An opening brace/bracket/paren (multi-line expression)
- * - A comma (array/object literal or params)
- * - An operator that clearly continues (+, -, *, /, =, etc.)
- * - A keyword that expects continuation (return, throw, etc. followed by value)
- */
-export declare function insertAsiProtection(source: string): string;
-/**
- * Transform == and != to Is() and IsNot() calls
- *
- * In TJS normal mode:
- *   a == b   -> Is(a, b)     (structural equality)
- *   a != b   -> IsNot(a, b)  (structural inequality)
- *   a === b  -> a === b      (identity, unchanged)
- *
- * Uses a two-pass algorithm:
- * 1. Find all == and != positions (outside strings/comments/regex)
- * 2. Transform from end to start (so positions remain valid)
- */
-export declare function transformEqualityToStructural(source: string): string;
-/**
- * Transform Type block declarations
- *
- * Syntax forms:
- *   Type Foo 'example'                    -> const Foo = Type('Foo', 'example')
- *   Type Foo { example: 'value' }         -> const Foo = Type('Foo', 'value')
- *   Type Foo 'description' { example: 'value' }
- *                                         -> const Foo = Type('description', 'value')
- *   Type Foo 'description' { example: 0, predicate(x) { return x > 0 } }
- *                                         -> const Foo = Type('description', (x) => { ... }, 0)
- *
- * When predicate + example: auto-generate type guard from example
- */
-export declare function transformTypeDeclarations(source: string): string;
-/**
- * Transform FunctionPredicate declarations
- *
- * Block form:
- *   FunctionPredicate Callback {
- *     params: { x: 0, y: '' }
- *     returns: false
- *   }
- *   → const Callback = FunctionPredicate('Callback', { params: { x: 0, y: '' }, returns: false })
- *
- * Generic block form:
- *   FunctionPredicate Creator<T = {}> {
- *     params: { contents: [null] }
- *     returns: T
- *   }
- *   → const Creator = FunctionPredicate('Creator', [['T', {}]], (T) => ({ params: { contents: [null] }, returns: T }))
- *
- * Function form:
- *   FunctionPredicate Handler(existingFn, 'description')
- *   → const Handler = FunctionPredicate('description', existingFn)
- */
-export declare function transformFunctionPredicateDeclarations(source: string): string;
-/**
- * Transform Generic block declarations
- *
- * Syntax:
- *   Generic Pair<T, U> { description: '...', predicate(obj, T, U) { ... } }
- *   Generic Container<T, U = ''> { ... }  // U has default
- *
- * Transforms to:
- *   const Pair = Generic(['T', 'U'], (obj, checkT, checkU) => { ... }, '...')
- *   const Container = Generic(['T', ['U', '']], (obj, checkT, checkU) => { ... }, '...')
- */
-export declare function transformGenericDeclarations(source: string): string;
-/**
- * Transform Union declarations
- *
- * Syntax:
- *   Union Direction 'cardinal direction' {
- *     'up' | 'down' | 'left' | 'right'
- *   }
- *
- * Transforms to:
- *   const Direction = Union('cardinal direction', ['up', 'down', 'left', 'right'])
- *
- * Also supports inline form:
- *   Union Direction 'cardinal direction' 'up' | 'down' | 'left' | 'right'
- */
-export declare function transformUnionDeclarations(source: string): string;
-/**
- * Transform Enum declarations
- *
- * Syntax:
- *   Enum Status 'task status' {
- *     Pending
- *     Active
- *     Done
- *   }
- *
- *   Enum Color 'CSS color' {
- *     Red = 'red'
- *     Green = 'green'
- *     Blue = 'blue'
- *   }
- *
- * Transforms to:
- *   const Status = Enum('task status', { Pending: 0, Active: 1, Done: 2 })
- *   const Color = Enum('CSS color', { Red: 'red', Green: 'green', Blue: 'blue' })
- */
-export declare function transformEnumDeclarations(source: string): string;
-/**
- * Extension info for a single extend block
- */
-export declare function transformExtendDeclarations(source: string): {
-    source: string;
-    extensions: Map<string, Set<string>>;
-};
-/**
- * Transform method calls on known-type receivers to use extension objects.
- *
- * For literals and typed variables where the type is known:
- *   'hello'.capitalize()  ->  __ext_String.capitalize.call('hello')
- *   [1,2,3].last()        ->  __ext_Array.last.call([1,2,3])
- *
- * This is a best-effort source-level transform. For unknown types,
- * the runtime fallback (resolveExtension) handles it.
- */
-export declare function transformExtensionCalls(source: string, extensions: Map<string, Set<string>>): string;
-/**
- * Compute {line, column} from a character offset in source.
- */
-export declare function locAt(source: string, pos: number): {
-    line: number;
-    column: number;
-};
-/**
- * Find the end of a function body (matching closing brace).
- * Handles nested braces, strings, template literals, comments, and regex.
- * Returns the index AFTER the closing brace.
- */
-export declare function findFunctionBodyEnd(source: string, openBracePos: number): number;
-/**
- * Transform polymorphic functions: multiple function declarations with the
- * same name are merged into a single dispatcher function.
- *
- * Must be called AFTER transformParenExpressions (so params have = defaults)
- * but BEFORE wrapClassDeclarations.
- *
- * function greet(name = '') { ... }
- * function greet(first = '', last = '') { ... }
- *
- * becomes:
- *
- * function greet$1(name = '') { ... }
- * function greet$2(first = '', last = '') { ... }
- * function greet(...__args) {
- *   if (__args.length === 1 && typeof __args[0] === 'string') return greet$1(__args[0])
- *   if (__args.length === 2 && ...) return greet$2(__args[0], __args[1])
- *   return __tjs.typeError('greet', 'no matching overload', __args)
- * }
- */
-export declare function transformPolymorphicFunctions(source: string, requiredParams: Set<string>): {
-    source: string;
-    polymorphicNames: Set<string>;
-};
-/**
- * Transform bare assignments to const declarations
- *
- * Foo = ... -> const Foo = ...
- *
- * Only transforms assignments at statement level (start of line or after semicolon/brace)
- * where the identifier starts with uppercase (to avoid breaking normal assignments)
- */
-export declare function transformBareAssignments(source: string): string;
-/**
- * Parse source code into an Acorn AST
- */
-export declare function extractAndRunTests(source: string, skipTests?: boolean): {
-    source: string;
-    tests: TestBlock[];
-    errors: string[];
-};
-/**
- * Wrap class declarations to make them callable without `new`
- *
- * Transforms:
- *   class Foo { ... }
- * To:
- *   let Foo = class Foo { ... };
- *   Foo = new Proxy(Foo, { apply(t, _, a) { return Reflect.construct(t, a) } });
- *
- * This emits standalone JS with no runtime dependencies.
- */
-/**
- * Transform polymorphic constructors into static factory functions.
- *
- * When a class has multiple constructor() declarations, the first becomes
- * the real constructor and the rest become factory functions. The wrapClass
- * Proxy routes through a polymorphic dispatcher.
- *
- * class Point {
- *   constructor(x: 0.0, y: 0.0) { this.x = x; this.y = y }
- *   constructor(coords: { x: 0.0, y: 0.0 }) { this.x = coords.x; this.y = coords.y }
- * }
- *
- * becomes:
- *
- * class Point {
- *   constructor(x = 0.0, y = 0.0) { this.x = x; this.y = y }
- * }
- * function Point$ctor$2(coords = { x: 0.0, y: 0.0 }) { return new Point(coords.x, coords.y) }
- * // wrapClass Proxy dispatches through polymorphic factory
- */
-export declare function transformPolymorphicConstructors(source: string, requiredParams: Set<string>): {
-    source: string;
-    polyCtorClasses: Set<string>;
-};
-export declare function wrapClassDeclarations(source: string, polyCtorClasses?: Set<string>): string;
-/**
- * Validate that Date is not used (TjsDate mode)
- * Throws an error if Date constructor or static methods are found
- */
-export declare function validateNoDate(source: string): string;
-/**
- * Validate that eval and Function constructor are not used (TjsNoeval mode)
- * Note: Eval and SafeFunction from TJS runtime are allowed
- */
-export declare function validateNoEval(source: string): string;