@elliots/typical 0.2.3 → 0.2.5

package/src/transformer.ts

@@ -6,41 +6,41 @@
  * and communication with the Go process.
  */
 
-import { resolve } from 'path'
-import { TypicalCompiler, type ProjectHandle, type RawSourceMap } from '@elliots/typical-compiler'
-import type { TypicalConfig } from './config.js'
-import { loadConfig } from './config.js'
+import { resolve } from "path";
+import { TypicalCompiler, type ProjectHandle, type RawSourceMap } from "@elliots/typical-compiler";
+import type { TypicalConfig } from "./config.js";
+import { loadConfig } from "./config.js";
 
 export interface TransformResult {
-  code: string
-  map: RawSourceMap | null
+  code: string;
+  map: RawSourceMap | null;
 }
 
 export class TypicalTransformer {
-  public config: TypicalConfig
-  private compiler: TypicalCompiler
-  private projectHandle: ProjectHandle | null = null
-  private initPromise: Promise<void> | null = null
-  private configFile: string
+  public config: TypicalConfig;
+  private compiler: TypicalCompiler;
+  private projectHandle: ProjectHandle | null = null;
+  private initPromise: Promise<void> | null = null;
+  private configFile: string;
 
-  constructor(config?: TypicalConfig, configFile: string = 'tsconfig.json') {
-    this.config = config ?? loadConfig()
-    this.configFile = configFile
-    this.compiler = new TypicalCompiler({ cwd: process.cwd() })
+  constructor(config?: TypicalConfig, configFile: string = "tsconfig.json") {
+    this.config = config ?? loadConfig();
+    this.configFile = configFile;
+    this.compiler = new TypicalCompiler({ cwd: process.cwd() });
   }
 
   /**
    * Ensure the Go compiler is started and project is loaded.
    * Uses lazy initialization - only starts on first transform.
    */
-  private async ensureInitialized(): Promise<void> {
+  private async ensureInitialized(x?: string): Promise<void> {
     if (!this.initPromise) {
       this.initPromise = (async () => {
-        await this.compiler.start()
-        this.projectHandle = await this.compiler.loadProject(this.configFile)
-      })()
+        await this.compiler.start();
+        this.projectHandle = await this.compiler.loadProject(this.configFile);
+      })();
     }
-    await this.initPromise
+    await this.initPromise;
   }
 
   /**
@@ -50,21 +50,26 @@ export class TypicalTransformer {
    * @param mode - Output mode: 'ts' returns TypeScript, 'js' would transpile (not yet supported)
    * @returns Transformed code with validation
    */
-  async transform(fileName: string, mode: 'ts' | 'js' = 'ts'): Promise<TransformResult> {
-    if (mode === 'js') {
-      throw new Error('Mode "js" not yet supported - use "ts" and transpile separately')
+  async transform(fileName: string, mode: "ts" | "js" = "ts"): Promise<TransformResult> {
+    if (mode === "js") {
+      throw new Error('Mode "js" not yet supported - use "ts" and transpile separately');
     }
 
-    await this.ensureInitialized()
+    await this.ensureInitialized();
 
-    const resolvedPath = resolve(fileName)
+    const resolvedPath = resolve(fileName);
     // Pass config options to the Go compiler
-    const result = await this.compiler.transformFile(this.projectHandle!, resolvedPath, this.config.ignoreTypes, this.config.maxGeneratedFunctions, this.config.reusableValidators)
+    const result = await this.compiler.transformFile(
+      this.projectHandle!,
+      resolvedPath,
+      this.config.ignoreTypes,
+      this.config.maxGeneratedFunctions,
+    );
 
     return {
       code: result.code,
       map: result.sourceMap ?? null,
-    }
+    };
   }
 
   /**
@@ -72,8 +77,8 @@ export class TypicalTransformer {
    * This immediately kills the process without waiting for pending operations.
    */
   async close(): Promise<void> {
-    this.projectHandle = null
-    this.initPromise = null
-    await this.compiler.close()
+    this.projectHandle = null;
+    this.initPromise = null;
+    await this.compiler.close();
   }
 }

package/dist/src/cli.typical.ts

@@ -1,136 +0,0 @@
-#!/usr/bin/env node
-import typia from "typia";
-//@L:3
-import { Command } from 'commander';
-//@L:4
-import * as fs from 'fs';
-//@L:5
-import * as path from 'path';
-//@L:6
-import { TypicalTransformer } from './transformer.js';
-//@L:7
-import * as ts from 'typescript';
-//@L:8
-import { loadConfig, validateConfig } from './config.js';
-//@L:9
-import { shouldIncludeFile } from './file-filter.js';
-//@L:10
-import { inlineSourceMapComment, externalSourceMapComment } from './source-map.js';
-//@L:12
-const program = new Command();
-//@L:14
-program
-    .name('typical')
-    .description('Runtime safe TypeScript transformer using typia')
-    .version('0.1.0');
-//@L:19
-program
-    .command('transform')
-    .description('Transform a TypeScript file with runtime validation')
-    .argument('<file>', 'TypeScript file to transform')
-    .option('-o, --output <file>', 'Output file')
-    .option('-c, --config <file>', 'Config file path', 'typical.json')
-    .option('-m, --mode <mode>', 'Transformation mode:  basic, typia, js', 'basic')
-    .option('--source-map', 'Generate external source map file')
-    .option('--inline-source-map', 'Include inline source map in output')
-    .option('--no-source-map', 'Disable source map generation')
-    .action(async (file: string, options: {
-    output?: string;
-    config?: string;
-    mode?: 'basic' | 'typia' | 'js';
-    sourceMap?: boolean;
-    inlineSourceMap?: boolean;
-}) => {
-    try {
-        const config = validateConfig(loadConfig(options.config));
-        const transformer = new TypicalTransformer(config);
-        if (!fs.existsSync(file)) {
-            console.error(`File not found: ${file}`);
-            process.exit(1);
-        }
-        // Determine source map behavior
-        const generateSourceMap = options.inlineSourceMap || options.sourceMap !== false;
-        console.log(`Transforming ${file}...`);
-        const result = transformer.transform(path.resolve(file), options.mode ?? 'basic', {
-            sourceMap: generateSourceMap,
-        });
-        // Determine output file path
-        const outputFile = options.output
-            ? path.resolve(options.output)
-            : options.mode === 'js'
-                ? file.replace(/\.tsx?$/, '.js')
-                : file + '.transformed.ts';
-        let outputCode = result.code;
-        // Handle source maps
-        if (result.map) {
-            if (options.inlineSourceMap) {
-                // Inline source map as data URL
-                outputCode += '\n' + inlineSourceMapComment(result.map);
-            }
-            else if (options.sourceMap !== false) {
-                // Write external source map file
-                const mapFile = outputFile + '.map';
-                fs.writeFileSync(mapFile, typia.json.stringify(result.map, null, 2));
-                outputCode += '\n' + externalSourceMapComment(path.basename(mapFile));
-                console.log(`Source map written to ${mapFile}`);
-            }
-        }
-        fs.writeFileSync(outputFile, outputCode);
-        console.log(`Transformed code written to ${outputFile}`);
-    }
-    catch (error) {
-        console.error('Transformation failed:', error);
-        process.exit(1);
-    }
-});
-// program
-//   .command('build')
-//   .description('Transform all TypeScript files in the project')
-//   .option('-c, --config <file>', 'Config file path')
-//   .option('--dry-run', 'Show what would be transformed without making changes')
-//   .action(async (options: { config?: string, dryRun?: boolean }) => {
-//     try {
-//       const transformer = new TypicalTransformer();
-//       const { glob } = await import('glob');
-//       const config = loadConfig(options.config);
-//       if (!config.include || config.include.length === 0) {
-//         console.error('No include patterns specified in config');
-//         process.exit(1);
-//       }
-//       const files: string[] = [];
-//       for (const pattern of config.include) {
-//         const matched = await glob(pattern, { 
-//           ignore: config.exclude,
-//           absolute: true 
-//         });
-//         files.push(...matched);
-//       }
-//       console.log(`Found ${files.length} files to transform`);
-//       if (options.dryRun) {
-//         files.forEach(file => console.log(`Would transform: ${file}`));
-//         return;
-//       }
-//       let transformed = 0;
-//       for (const file of files) {
-//         // Double-check with our shared filtering logic
-//         if (!shouldIncludeFile(file, config)) {
-//           console.log(`Skipping ${file} (excluded by filters)`);
-//           continue;
-//         }
-//         try {
-//           console.log(`Transforming ${file}...`);
-//           const transformedCode = transformer.transformFile(file, ts);
-//           fs.writeFileSync(file, transformedCode);
-//           transformed++;
-//         } catch (error) {
-//           console.error(`Failed to transform ${file}:`, error);
-//         }
-//       }
-//       console.log(`Successfully transformed ${transformed}/${files.length} files`);
-//     } catch (error) {
-//       console.error('Build failed:', error);
-//       process.exit(1);
-//     }
-//   });
-//@L:145
-program.parse();

package/dist/src/config.typical.ts

@@ -1,287 +0,0 @@
-import typia from "typia";
-//@L:1
-export interface TypicalDebugConfig {
-    //@L:2
-    writeIntermediateFiles?: boolean;
-}
-/**
- * Configuration options for source map generation.
- */
-//@L:8
-export interface TypicalSourceMapConfig {
-    /**
-     * Generate source maps. Default: true
-     */
-    //@L:12
-    enabled?: boolean;
-    /**
-     * Include original source content in the map. Default: true
-     */
-    //@L:16
-    includeContent?: boolean;
-    /**
-     * Use inline source maps (data URL) instead of external files. Default: false
-     */
-    //@L:20
-    inline?: boolean;
-}
-//@L:23
-export interface TypicalConfig {
-    //@L:24
-    include?: string[];
-    //@L:25
-    exclude?: string[];
-    //@L:26
-    reusableValidators?: boolean;
-    //@L:27
-    validateCasts?: boolean;
-    //@L:28
-    hoistRegex?: boolean;
-    //@L:29
-    debug?: TypicalDebugConfig;
-    /**
-     * Type patterns to skip validation for (supports wildcards).
-     * Use this for types that typia cannot process (e.g., React event types).
-     * Example: ["React.*", "Express.Request", "*.Event"]
-     */
-    //@L:35
-    ignoreTypes?: string[];
-    /**
-     * Skip validation for DOM types (Document, Element, Node, etc.) and their subclasses.
-     * These types have complex Window intersections that typia cannot process.
-     * Default: true
-     */
-    //@L:41
-    ignoreDOMTypes?: boolean;
-    /**
-     * Validate function parameters and return types at runtime.
-     * When enabled, typed function parameters get runtime validation calls injected.
-     * Default: true
-     */
-    //@L:47
-    validateFunctions?: boolean;
-    /**
-     * Source map generation settings.
-     * Controls whether and how source maps are generated for transformed code.
-     */
-    //@L:52
-    sourceMap?: TypicalSourceMapConfig;
-}
-/**
- * Pre-compiled regex patterns for ignore type matching.
- * This is populated during config loading for performance.
- */
-//@L:59
-export interface CompiledIgnorePatterns {
-    /** Compiled patterns from user ignoreTypes config */
-    //@L:61
-    userPatterns: RegExp[];
-    /** Compiled patterns from DOM_TYPES_TO_IGNORE (when ignoreDOMTypes is true) */
-    //@L:63
-    domPatterns: RegExp[];
-    /** All patterns combined for quick checking */
-    //@L:65
-    allPatterns: RegExp[];
-}
-//@L:68
-export const defaultConfig: TypicalConfig = {
-    include: ["**/*.ts", "**/*.tsx"],
-    exclude: ["node_modules/**", "**/*.d.ts", "dist/**", "build/**"],
-    reusableValidators: false, // Off by default for accurate source maps (set to true for production)
-    validateCasts: false,
-    validateFunctions: true,
-    hoistRegex: true,
-    ignoreDOMTypes: true,
-    debug: {
-        writeIntermediateFiles: false,
-    },
-    sourceMap: {
-        enabled: true, // On by default for debugging (set to false for production)
-        includeContent: true,
-        inline: false,
-    },
-};
-// FIXME: find a better way to work out which types to ignore
-/**
- * DOM types that typia cannot process due to Window global intersections.
- * These are the base DOM types - classes extending them are checked separately.
- */
-//@L:91
-export const DOM_TYPES_TO_IGNORE = [
-    // Core DOM types
-    "Document",
-    "DocumentFragment",
-    "Element",
-    "Node",
-    "ShadowRoot",
-    "Window",
-    "EventTarget",
-    // HTML Elements
-    "HTML*Element",
-    "HTMLElement",
-    "HTMLCollection",
-    // SVG Elements
-    "SVG*Element",
-    "SVGElement",
-    // Events
-    "*Event",
-    // Other common DOM types
-    "NodeList",
-    "DOMTokenList",
-    "NamedNodeMap",
-    "CSSStyleDeclaration",
-    "Selection",
-    "Range",
-    "Text",
-    "Comment",
-    "CDATASection",
-    "ProcessingInstruction",
-    "DocumentType",
-    "Attr",
-    "Table",
-    "TableRow",
-    "TableCell",
-    "StyleSheet",
-];
-//@L:128
-import fs from 'fs';
-//@L:129
-import path from 'path';
-/**
- * Convert a glob pattern to a RegExp for type matching.
- * Supports wildcards: "React.*" -> /^React\..*$/
- */
-//@L:135
-export function compileIgnorePattern(pattern: string): RegExp | null {
-    //@L:136
-    try {
-        const regexStr = '^' + pattern
-            .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape special regex chars except *
-            .replace(/\*/g, '.*') + '$';
-        return new RegExp(regexStr);
-    }
-    catch (error) {
-        console.warn(`TYPICAL: Invalid ignoreTypes pattern "${pattern}": ${error}`);
-        return null;
-    }
-}
-/**
- * Pre-compile all ignore patterns for efficient matching.
- */
-//@L:150
-export function compileIgnorePatterns(config: TypicalConfig): CompiledIgnorePatterns {
-    //@L:151
-    const userPatterns: RegExp[] = [];
-    //@L:152
-    const domPatterns: RegExp[] = [];
-    // Compile user patterns
-    //@L:155
-    for (const pattern of config.ignoreTypes ?? []) {
-        const compiled = compileIgnorePattern(pattern);
-        if (compiled) {
-            userPatterns.push(compiled);
-        }
-    }
-    // Compile DOM patterns if enabled (default: true)
-    //@L:163
-    if (config.ignoreDOMTypes !== false) {
-        //@L:164
-        for (const pattern of DOM_TYPES_TO_IGNORE) {
-            const compiled = compileIgnorePattern(pattern);
-            if (compiled) {
-                domPatterns.push(compiled);
-            }
-        }
-    }
-    //@L:172
-    return {
-        userPatterns,
-        domPatterns,
-        allPatterns: [...userPatterns, ...domPatterns],
-    };
-}
-// Cache for compiled patterns, keyed by config identity
-//@L:180
-let cachedPatterns: CompiledIgnorePatterns | null = null;
-//@L:181
-let cachedConfig: TypicalConfig | null = null;
-/**
- * Get compiled ignore patterns, using cache if config hasn't changed.
- */
-//@L:186
-export function getCompiledIgnorePatterns(config: TypicalConfig): CompiledIgnorePatterns {
-    // Simple identity check - if same config object, use cache
-    //@L:188
-    if (cachedConfig === config && cachedPatterns) {
-        //@L:189
-        return cachedPatterns;
-    }
-    //@L:192
-    cachedConfig = config;
-    //@L:193
-    cachedPatterns = compileIgnorePatterns(config);
-    //@L:194
-    return cachedPatterns;
-}
-//@L:197
-export function loadConfig(configPath?: string): TypicalConfig {
-    //@L:198
-    const configFile = configPath || path.join(process.cwd(), 'typical.json');
-    //@L:200
-    if (fs.existsSync(configFile)) {
-        //@L:201
-        try {
-            const configContent = fs.readFileSync(configFile, 'utf8');
-            const userConfig: Partial<TypicalConfig> = typia.json.assertParse<Partial<TypicalConfig>>(configContent);
-            return {
-                ...defaultConfig,
-                ...userConfig,
-            };
-        }
-        catch (error) {
-            console.warn(`Failed to parse config file ${configFile}:`, error);
-            return defaultConfig;
-        }
-    }
-    //@L:215
-    return defaultConfig;
-}
-//@L:218
-let warnedAboutSourceMaps = false;
-/**
- * Validate and adjust config for consistency.
- * Currently handles:
- * - Disabling reusableValidators when source maps are enabled (required for accurate mappings)
- *
- * @param config The config to validate
- * @returns Validated/adjusted config
- */
-//@L:228
-export function validateConfig(config: TypicalConfig): TypicalConfig {
-    //@L:229
-    let result = config;
-    // Source maps require inline validators (not reusable) because each validation
-    // call needs its own source map marker pointing to the correct type annotation.
-    // With reusable validators, the expanded typia code would all map to the validator
-    // declaration rather than the individual usage sites.
-    //@L:235
-    const sourceMapEnabled = config.sourceMap?.enabled !== false;
-    //@L:236
-    const reusableValidatorsEnabled = config.reusableValidators === true;
-    //@L:238
-    if (sourceMapEnabled && reusableValidatorsEnabled) {
-        //@L:239
-        if (!warnedAboutSourceMaps) {
-            //@L:240
-            warnedAboutSourceMaps = true;
-            //@L:241
-            console.warn("TYPICAL: Both sourceMap and reusableValidators are enabled. " +
-                "Disabling reusableValidators for accurate source mapping. " +
-                "For production builds, set sourceMap.enabled: false to use reusableValidators.");
-        }
-        //@L:247
-        result = { ...result, reusableValidators: false };
-    }
-    //@L:250
-    return result;
-}

package/dist/src/file-filter.d.ts

@@ -1,13 +0,0 @@
-import type { TypicalConfig } from './config.js';
-/**
- * Determines if a file should be transformed based on include/exclude patterns
- */
-export declare function shouldTransformFile(fileName: string, config: TypicalConfig): boolean;
-/**
- * Checks if a file is a TypeScript file that can be transformed
- */
-export declare function isTransformableTypeScriptFile(fileName: string): boolean;
-/**
- * Combined check for both file type and include/exclude patterns
- */
-export declare function shouldIncludeFile(fileName: string, config: TypicalConfig): boolean;

package/dist/src/file-filter.js

@@ -1,42 +0,0 @@
-import * as path from 'path';
-import { minimatch } from 'minimatch';
-/**
- * Determines if a file should be transformed based on include/exclude patterns
- */
-export function shouldTransformFile(fileName, config) {
-    const relativePath = path.relative(process.cwd(), fileName);
-    // Exclude files outside the project directory (e.g., resolved symlinks to parent dirs)
-    if (relativePath.startsWith('..')) {
-        return false;
-    }
-    // Check include patterns
-    const isIncluded = config.include?.some(pattern => {
-        return minimatch(relativePath, pattern);
-    }) ?? true;
-    if (!isIncluded)
-        return false;
-    // Check exclude patterns
-    const isExcluded = config.exclude?.some(pattern => {
-        return minimatch(relativePath, pattern);
-    }) ?? false;
-    return !isExcluded;
-}
-/**
- * Checks if a file is a TypeScript file that can be transformed
- */
-export function isTransformableTypeScriptFile(fileName) {
-    // Only transform TypeScript files
-    if (!/\.(ts|tsx)$/.test(fileName))
-        return false;
-    // Skip declaration files
-    if (fileName.endsWith('.d.ts'))
-        return false;
-    return true;
-}
-/**
- * Combined check for both file type and include/exclude patterns
- */
-export function shouldIncludeFile(fileName, config) {
-    return isTransformableTypeScriptFile(fileName) && shouldTransformFile(fileName, config);
-}
-//# sourceMappingURL=file-filter.js.map

package/dist/src/file-filter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"file-filter.js","sourceRoot":"","sources":["../../src/file-filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAA;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAGrC;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAgB,EAAE,MAAqB;IACzE,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,CAAC,CAAA;IAE3D,uFAAuF;IACvF,IAAI,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QAClC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,yBAAyB;IACzB,MAAM,UAAU,GACd,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE;QAC7B,OAAO,SAAS,CAAC,YAAY,EAAE,OAAO,CAAC,CAAA;IACzC,CAAC,CAAC,IAAI,IAAI,CAAA;IAEZ,IAAI,CAAC,UAAU;QAAE,OAAO,KAAK,CAAA;IAE7B,yBAAyB;IACzB,MAAM,UAAU,GACd,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE;QAC7B,OAAO,SAAS,CAAC,YAAY,EAAE,OAAO,CAAC,CAAA;IACzC,CAAC,CAAC,IAAI,KAAK,CAAA;IAEb,OAAO,CAAC,UAAU,CAAA;AACpB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,6BAA6B,CAAC,QAAgB;IAC5D,kCAAkC;IAClC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC;QAAE,OAAO,KAAK,CAAA;IAE/C,yBAAyB;IACzB,IAAI,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,KAAK,CAAA;IAE5C,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAgB,EAAE,MAAqB;IACvE,OAAO,6BAA6B,CAAC,QAAQ,CAAC,IAAI,mBAAmB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;AACzF,CAAC"}

package/dist/src/program-manager.d.ts

@@ -1,27 +0,0 @@
-import ts from 'typescript';
-/**
- * Manages a shared TypeScript program across file transformations.
- * This avoids the expensive cost of creating a new program for each file.
- */
-export declare class ProgramManager {
-    private program;
-    private compilerOptions;
-    private sourceContents;
-    private sourceFileCache;
-    private host;
-    /**
-     * Get or create a program with the given source content for a file.
-     * Uses incremental compilation to reuse data from previous program.
-     */
-    getProgram(id: string, source: string): ts.Program;
-    /**
-     * Get the source file for a given ID from the current program.
-     */
-    getSourceFile(id: string): ts.SourceFile | undefined;
-    /**
-     * Reset the program manager state (e.g., at build start).
-     */
-    reset(): void;
-    private loadCompilerOptions;
-    private createHost;
-}