@elliots/typical 0.1.0

package/src/cli.ts

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { TypicalTransformer } from './transformer.js';
+import * as ts from 'typescript';
+import { loadConfig } from './config.js';
+import { shouldIncludeFile } from './file-filter.js';
+
+const program = new Command();
+
+program
+  .name('typical')
+  .description('Runtime safe TypeScript transformer using typia')
+  .version('0.1.0');
+
+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')
+  .action(async (file: string, options: { output?: string; config?: string; mode?: 'basic' | 'typia' | 'js' }) => {
+    try {
+      const config = loadConfig(options.config);
+      const transformer = new TypicalTransformer(config);
+      
+      if (!fs.existsSync(file)) {
+        console.error(`File not found: ${file}`);
+        process.exit(1);
+      }
+
+      console.log(`Transforming ${file}...`);
+      const transformedCode = transformer.transform(path.resolve(file), options.mode ?? 'basic');
+
+      const outputFilename = options.output ? path.resolve(options.output) : options.mode === 'js' ? file + '.js' : file + '.transformed.ts';
+      
+      const outputFile = options.output ? path.resolve(options.output) : file + '.transformed.ts';
+      fs.writeFileSync(outputFile, transformedCode);
+      
+      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);
+//     }
+//   });
+
+program.parse();

package/src/config.ts

@@ -0,0 +1,35 @@
+export interface TypicalConfig {
+  include?: string[];
+  exclude?: string[];
+  reusableValidators?: boolean;
+}
+
+export const defaultConfig: TypicalConfig = {
+  include: ["**/*.ts", "**/*.tsx"],
+  exclude: ["node_modules/**", "**/*.d.ts", "dist/**", "build/**"],
+  reusableValidators: true,
+};
+
+import fs from 'fs';
+import path from 'path';
+
+export function loadConfig(configPath?: string): TypicalConfig {
+  const configFile = configPath || path.join(process.cwd(), 'typical.json');
+  
+  if (fs.existsSync(configFile)) {
+    try {
+      const configContent = fs.readFileSync(configFile, 'utf8');
+      const userConfig: Partial<TypicalConfig> = JSON.parse(configContent);
+      
+      return {
+        ...defaultConfig,
+        ...userConfig,
+      };
+    } catch (error) {
+      console.warn(`Failed to parse config file ${configFile}:`, error);
+      return defaultConfig;
+    }
+  }
+
+  return defaultConfig;
+}

package/src/esm-loader-register.ts

@@ -0,0 +1,2 @@
+import { register } from 'node:module';
+register('./esm-loader.js', { parentURL: import.meta.url });

package/src/esm-loader.ts

@@ -0,0 +1,26 @@
+import { fileURLToPath } from "url";
+import { TypicalTransformer } from "./transformer.js";
+
+const transformer = new TypicalTransformer();
+
+/**
+ * Load hook - transforms TypeScript files on the fly
+ */
+export async function load(url: string, context: any, nextLoad: any) {
+  if (!url.endsWith(".ts")) {
+    return nextLoad(url, context);
+  }
+  const filePath = fileURLToPath(url);
+
+  try {
+    const transformedCode = transformer.transform(filePath, 'js');
+    return {
+      format: "module",
+      source: transformedCode,
+      shortCircuit: true,
+    };
+  } catch (error) {
+    console.error(`Error transforming ${filePath}:`, error);
+    throw error;
+  }
+}

package/src/file-filter.ts

@@ -0,0 +1,44 @@
+import * as path from 'path';
+import { minimatch } from 'minimatch';
+import { TypicalConfig } from './config.js';
+
+/**
+ * Determines if a file should be transformed based on include/exclude patterns
+ */
+export function shouldTransformFile(fileName: string, config: TypicalConfig): boolean {
+  const relativePath = path.relative(process.cwd(), fileName);
+  
+  // 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: string): boolean {
+  // 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: string, config: TypicalConfig): boolean {
+  return isTransformableTypeScriptFile(fileName) && shouldTransformFile(fileName, config);
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { TypicalTransformer } from './transformer.js';
+export { loadConfig, defaultConfig, TypicalConfig } from './config.js';

package/src/patch-fs.cjs

@@ -0,0 +1,25 @@
+// logs all readFile and readFileSync calls (for debugging)
+
+const fs = require("fs");
+const fsp = require("fs/promises");
+
+// monkeypatch promises/readFile
+const origFspReadFile = fsp.readFile;
+fsp.readFile = async function (path, ...args) {
+  console.log("fsp.readFile", path);
+  return origFspReadFile.call(this, path, ...args);
+};
+
+// monkeypatch readFile
+const origFsReadFile = fs.readFile;
+fs.readFile = async function (path, ...args) {
+  console.log("fs.readFile", path);
+  return origFsReadFile.call(this, path, ...args);
+};
+
+// monkeypatch readFileSync
+const origFsReadFileSync = fs.readFileSync;
+fs.readFileSync = function (path, ...args) {
+  console.log("fs.readFileSync", path);
+  return origFsReadFileSync.call(this, path, ...args);
+};

package/src/patch-tsconfig.cjs

@@ -0,0 +1,52 @@
+// monkeypatch fs.readFileSync to automatically add typical/tsc-plugin to tsconfig.json (if not present)
+
+const fs = require("fs");
+const stripJsonComments = require('strip-json-comments').default;
+
+const origFsReadFileSync = fs.readFileSync;
+
+fs.readFileSync = function (path, ...args) {
+  const result = origFsReadFileSync.call(this, path, ...args);
+
+  if (typeof path === "string" && path.endsWith("/tsconfig.json")) {
+    try {
+
+      const json = stripJsonComments(result.toString(), { trailingCommas: true });
+
+      const config = JSON.parse(json);
+      
+      if (!config.compilerOptions) {
+        config.compilerOptions = {};
+      }
+
+      if (!config.compilerOptions.plugins) {
+        config.compilerOptions.plugins = [];
+      }
+
+      const hasTypical = config.compilerOptions.plugins.some(
+        (plugin) => plugin.transform === "typical/tsc-plugin"
+      );
+
+      if (!hasTypical) {
+        if (fs.existsSync("./dist/src/tsc-plugin.js")) {
+          console.log("DEV MODE: Adding ./dist/src/tsc-plugin.js to tsconfig.json");
+          config.compilerOptions.plugins.push({
+            transform: "./dist/src/tsc-plugin.js",
+          });
+        } else {
+          config.compilerOptions.plugins.push({
+            transform: "typical/tsc-plugin",
+          });
+        }
+      }
+
+      // console.log("patched config", JSON.stringify(config, null, 2));
+
+      return JSON.stringify(config, null, 2);
+    } catch (e) {
+      console.error("ERROR patching tsconfig.json to add typical/tsc-plugin", e);
+      throw e;
+    }
+  }
+  return result;
+};

package/src/setup.ts

@@ -0,0 +1,29 @@
+import type ts from "typescript";
+
+export function setupTsProgram(tsInstance: typeof ts): ts.Program {
+  // Find tsconfig.json
+  const tsConfigPath = tsInstance.findConfigFile(
+    process.cwd(),
+    tsInstance.sys.fileExists,
+    "tsconfig.json"
+  );
+  if (!tsConfigPath) {
+    throw new Error("Could not find tsconfig.json");
+  }
+
+  // Load and parse tsconfig.json
+  const configFile = tsInstance.readConfigFile(tsConfigPath, tsInstance.sys.readFile);
+  const parsedConfig = tsInstance.parseJsonConfigFileContent(
+    configFile.config,
+    tsInstance.sys,
+    process.cwd()
+  );
+
+  // Create the TypeScript program with all project files
+  const tsProgram = tsInstance.createProgram(
+    parsedConfig.fileNames,
+    parsedConfig.options
+  );
+
+  return tsProgram;
+}