jpsx 0.1.16

package/dist/api/__tests__/runtime.test.js

@@ -0,0 +1,275 @@
+import { compile } from "../index.js";
+describe("Runtime Functions - Execution Tests", () => {
+    // Helper to execute compiled code and capture output
+    const executeCode = (source) => {
+        const logs = [];
+        const originalLog = console.log;
+        console.log = (...args) => {
+            logs.push(args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' '));
+        };
+        try {
+            const result = compile(source, {
+                format: "iife",
+                runtimeMode: "inline",
+                moduleName: "TestModule"
+            });
+            // Execute in isolated context
+            eval(result.code);
+        }
+        finally {
+            console.log = originalLog;
+        }
+        return logs;
+    };
+    describe("print() function", () => {
+        test("should print string", () => {
+            const output = executeCode('print("Hello World")');
+            expect(output).toContain("Hello World");
+        });
+        test("should print numbers", () => {
+            const output = executeCode('print(42)');
+            expect(output).toContain("42");
+        });
+        test("should print multiple arguments", () => {
+            const output = executeCode('print("Answer:", 42)');
+            expect(output[0]).toContain("Answer:");
+            expect(output[0]).toContain("42");
+        });
+    });
+    describe("range() function", () => {
+        test("should generate range with single argument", () => {
+            const output = executeCode(`
+numbers = range(5)
+for n in numbers:
+    print(n)
+      `);
+            expect(output).toHaveLength(5);
+            expect(output).toEqual(["0", "1", "2", "3", "4"]);
+        });
+        test("should generate range with start and stop", () => {
+            const output = executeCode(`
+numbers = range(2, 5)
+for n in numbers:
+    print(n)
+      `);
+            expect(output).toEqual(["2", "3", "4"]);
+        });
+        test("should generate range with step", () => {
+            const output = executeCode(`
+numbers = range(0, 10, 2)
+for n in numbers:
+    print(n)
+      `);
+            expect(output).toEqual(["0", "2", "4", "6", "8"]);
+        });
+    });
+    describe("sum() function", () => {
+        test("should sum array of numbers", () => {
+            const output = executeCode(`
+numbers = [1, 2, 3, 4, 5]
+total = sum(numbers)
+print(total)
+      `);
+            expect(output).toContain("15");
+        });
+        test("should sum range", () => {
+            const output = executeCode(`
+total = sum(range(1, 11))
+print(total)
+      `);
+            expect(output).toContain("55");
+        });
+    });
+    describe("len() function", () => {
+        test("should return length of array", () => {
+            const output = executeCode(`
+arr = [1, 2, 3, 4, 5]
+print(len(arr))
+      `);
+            expect(output).toContain("5");
+        });
+        test("should return length of string", () => {
+            const output = executeCode(`
+text = "Hello"
+print(len(text))
+      `);
+            expect(output).toContain("5");
+        });
+    });
+    describe("min() and max() functions", () => {
+        test("should find minimum", () => {
+            const output = executeCode(`
+numbers = [5, 2, 8, 1, 9]
+print(min(numbers))
+      `);
+            expect(output).toContain("1");
+        });
+        test("should find maximum", () => {
+            const output = executeCode(`
+numbers = [5, 2, 8, 1, 9]
+print(max(numbers))
+      `);
+            expect(output).toContain("9");
+        });
+    });
+    describe("sorted() function", () => {
+        test("should sort array ascending", () => {
+            const output = executeCode(`
+numbers = [5, 2, 8, 1, 9]
+sorted_nums = sorted(numbers)
+print(sorted_nums)
+      `);
+            expect(output[0]).toContain("1");
+            expect(output[0]).toContain("9");
+        });
+        test("should sort array descending", () => {
+            const output = executeCode(`
+numbers = [5, 2, 8, 1, 9]
+sorted_nums = sorted(numbers, True)
+print(sorted_nums[0])
+      `);
+            expect(output[0]).toContain("9");
+        });
+    });
+    describe("Type conversion functions", () => {
+        test("str() should convert to string", () => {
+            const output = executeCode(`
+num = 42
+text = str(num)
+print(text)
+      `);
+            expect(output).toContain("42");
+        });
+        test("int() should convert to integer", () => {
+            const output = executeCode(`
+text = "42"
+num = int(text)
+print(num)
+      `);
+            expect(output).toContain("42");
+        });
+        test("float() should convert to float", () => {
+            const output = executeCode(`
+text = "3.14"
+num = float(text)
+print(num)
+      `);
+            expect(output).toContain("3.14");
+        });
+    });
+    describe("List comprehensions", () => {
+        test("should execute simple list comprehension", () => {
+            const output = executeCode(`
+numbers = [x * 2 for x in range(5)]
+print(numbers)
+      `);
+            expect(output[0]).toContain("0");
+            expect(output[0]).toContain("8");
+        });
+        test("should execute nested list comprehension", () => {
+            const output = executeCode(`
+squares = [x * x for x in range(1, 6)]
+for s in squares:
+    print(s)
+      `);
+            expect(output).toEqual(["1", "4", "9", "16", "25"]);
+        });
+    });
+    describe("Functions", () => {
+        test("should define and call function", () => {
+            const output = executeCode(`
+def greet(name):
+    return "Hello, " + name
+
+message = greet("World")
+print(message)
+      `);
+            expect(output).toContain("Hello, World");
+        });
+        test("should handle multiple parameters", () => {
+            const output = executeCode(`
+def add(a, b):
+    return a + b
+
+result = add(5, 3)
+print(result)
+      `);
+            expect(output).toContain("8");
+        });
+        test("should support recursion", () => {
+            const output = executeCode(`
+def factorial(n):
+    if n <= 1:
+        return 1
+    return n * factorial(n - 1)
+
+result = factorial(5)
+print(result)
+      `);
+            expect(output).toContain("120");
+        });
+    });
+    describe("Control Flow", () => {
+        test("should execute if-else", () => {
+            const output = executeCode(`
+x = 10
+if x > 5:
+    print("big")
+else:
+    print("small")
+      `);
+            expect(output).toContain("big");
+        });
+        test("should execute for loops", () => {
+            const output = executeCode(`
+for i in range(3):
+    print(i)
+      `);
+            expect(output).toEqual(["0", "1", "2"]);
+        });
+        test("should execute while loops", () => {
+            const output = executeCode(`
+x = 0
+while x < 3:
+    print(x)
+    x = x + 1
+      `);
+            expect(output).toEqual(["0", "1", "2"]);
+        });
+    });
+    describe("Complex Programs", () => {
+        test("should calculate fibonacci", () => {
+            const output = executeCode(`
+def fib(n):
+    if n <= 1:
+        return n
+    return fib(n - 1) + fib(n - 2)
+
+result = fib(10)
+print(result)
+      `);
+            expect(output).toContain("55");
+        });
+        test("should filter even numbers", () => {
+            const output = executeCode(`
+numbers = range(10)
+evens = [x for x in numbers if x % 2 == 0]
+print(evens)
+      `);
+            expect(output[0]).toContain("0");
+            expect(output[0]).toContain("8");
+        });
+        test("should combine multiple operations", () => {
+            const output = executeCode(`
+def square(x):
+    return x * x
+
+numbers = range(1, 6)
+squares = [square(x) for x in numbers]
+total = sum(squares)
+print(total)
+      `);
+            expect(output).toContain("55");
+        });
+    });
+});

package/dist/api/advanced.d.ts

@@ -0,0 +1,100 @@
+import { CompileOptions, CompileResult } from "./index.js";
+/**
+ * Compile with caching support
+ *
+ * @param source - JPS source code
+ * @param options - Compilation options
+ * @param cacheKey - Optional cache key (defaults to source hash)
+ * @returns Compiled result (from cache if available)
+ *
+ * @example
+ * ```typescript
+ * const result = compileWithCache(source, options, 'my-file.jps');
+ * ```
+ */
+export declare function compileWithCache(source: string, options?: CompileOptions, cacheKey?: string): CompileResult;
+/**
+ * Clear the compilation cache
+ *
+ * @param cacheKey - Optional key to clear (clears all if not provided)
+ */
+export declare function clearCache(cacheKey?: string): void;
+/**
+ * Get cache statistics
+ */
+export declare function getCacheStats(): {
+    size: number;
+    entries: string[];
+};
+/**
+ * Watch a file for changes and recompile
+ *
+ * @param filePath - Path to JPS file to watch
+ * @param options - Compilation options
+ * @param callback - Function called on each compilation
+ * @returns Function to stop watching
+ *
+ * @example
+ * ```typescript
+ * const stopWatching = watch('script.jps', {}, (result, error) => {
+ *   if (error) console.error(error);
+ *   else console.log(result.code);
+ * });
+ *
+ * // Later: stop watching
+ * stopWatching();
+ * ```
+ */
+export declare function watch(filePath: string, options: CompileOptions | undefined, callback: (result: CompileResult | null, error: Error | null) => void): () => void;
+/**
+ * Compile a file and write output to disk
+ *
+ * @param inputPath - Input JPS file path
+ * @param outputPath - Output JS file path (optional, defaults to .js extension)
+ * @param options - Compilation options
+ *
+ * @example
+ * ```typescript
+ * await compileFile('script.jps', 'script.js', {
+ *   format: 'esm',
+ *   runtimeMode: 'external'
+ * });
+ * ```
+ */
+export declare function compileFile(inputPath: string, outputPath?: string, options?: CompileOptions): Promise<void>;
+/**
+ * Compile multiple files
+ *
+ * @param files - Array of file paths or {input, output} objects
+ * @param options - Compilation options
+ *
+ * @example
+ * ```typescript
+ * await compileFiles([
+ *   { input: 'src/main.jps', output: 'dist/main.js' },
+ *   { input: 'src/util.jps', output: 'dist/util.js' }
+ * ], { format: 'esm' });
+ * ```
+ */
+export declare function compileFiles(files: Array<string | {
+    input: string;
+    output?: string;
+}>, options?: CompileOptions): Promise<void>;
+/**
+ * Batch compile with progress tracking
+ *
+ * @param files - Array of file paths
+ * @param options - Compilation options
+ * @param onProgress - Progress callback
+ *
+ * @example
+ * ```typescript
+ * await batchCompile(
+ *   ['file1.jps', 'file2.jps', 'file3.jps'],
+ *   { format: 'esm' },
+ *   (completed, total) => console.log(`${completed}/${total}`)
+ * );
+ * ```
+ */
+export declare function batchCompile(files: string[], options?: CompileOptions, onProgress?: (completed: number, total: number) => void): Promise<void>;
+//# sourceMappingURL=advanced.d.ts.map

package/dist/api/advanced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.d.ts","sourceRoot":"","sources":["../../src/api/advanced.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AASpE;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,EAC5B,QAAQ,CAAC,EAAE,MAAM,GAChB,aAAa,CAkBf;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAMlD;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAKnE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,KAAK,CACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,cAAc,YAAK,EAC5B,QAAQ,EAAE,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,GACpE,MAAM,IAAI,CA2BZ;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,WAAW,CAC/B,SAAS,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,MAAM,EACnB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAWf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,KAAK,CAAC,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,EACzD,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAUf;AAeD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,GAAE,cAAmB,EAC5B,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GACtD,OAAO,CAAC,IAAI,CAAC,CAWf"}

package/dist/api/advanced.js

@@ -0,0 +1,192 @@
+import { compile } from "./index.js";
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Cache for compiled results
+ */
+const compilationCache = new Map();
+/**
+ * Compile with caching support
+ *
+ * @param source - JPS source code
+ * @param options - Compilation options
+ * @param cacheKey - Optional cache key (defaults to source hash)
+ * @returns Compiled result (from cache if available)
+ *
+ * @example
+ * ```typescript
+ * const result = compileWithCache(source, options, 'my-file.jps');
+ * ```
+ */
+export function compileWithCache(source, options = {}, cacheKey) {
+    const key = cacheKey || hashSource(source);
+    const cached = compilationCache.get(key);
+    // Check if cache is valid
+    if (cached && cached.source === source) {
+        return cached.result;
+    }
+    // Compile and cache
+    const result = compile(source, options);
+    compilationCache.set(key, {
+        source,
+        result,
+        timestamp: Date.now()
+    });
+    return result;
+}
+/**
+ * Clear the compilation cache
+ *
+ * @param cacheKey - Optional key to clear (clears all if not provided)
+ */
+export function clearCache(cacheKey) {
+    if (cacheKey) {
+        compilationCache.delete(cacheKey);
+    }
+    else {
+        compilationCache.clear();
+    }
+}
+/**
+ * Get cache statistics
+ */
+export function getCacheStats() {
+    return {
+        size: compilationCache.size,
+        entries: Array.from(compilationCache.keys())
+    };
+}
+/**
+ * Watch a file for changes and recompile
+ *
+ * @param filePath - Path to JPS file to watch
+ * @param options - Compilation options
+ * @param callback - Function called on each compilation
+ * @returns Function to stop watching
+ *
+ * @example
+ * ```typescript
+ * const stopWatching = watch('script.jps', {}, (result, error) => {
+ *   if (error) console.error(error);
+ *   else console.log(result.code);
+ * });
+ *
+ * // Later: stop watching
+ * stopWatching();
+ * ```
+ */
+export function watch(filePath, options = {}, callback) {
+    const absolutePath = path.resolve(filePath);
+    // Initial compilation
+    try {
+        const source = fs.readFileSync(absolutePath, 'utf-8');
+        const result = compile(source, options);
+        callback(result, null);
+    }
+    catch (error) {
+        callback(null, error);
+    }
+    // Watch for changes
+    const watcher = fs.watchFile(absolutePath, { interval: 1000 }, () => {
+        try {
+            const source = fs.readFileSync(absolutePath, 'utf-8');
+            const result = compile(source, options);
+            callback(result, null);
+        }
+        catch (error) {
+            callback(null, error);
+        }
+    });
+    // Return stop function
+    return () => {
+        fs.unwatchFile(absolutePath);
+    };
+}
+/**
+ * Compile a file and write output to disk
+ *
+ * @param inputPath - Input JPS file path
+ * @param outputPath - Output JS file path (optional, defaults to .js extension)
+ * @param options - Compilation options
+ *
+ * @example
+ * ```typescript
+ * await compileFile('script.jps', 'script.js', {
+ *   format: 'esm',
+ *   runtimeMode: 'external'
+ * });
+ * ```
+ */
+export async function compileFile(inputPath, outputPath, options = {}) {
+    const source = await fs.promises.readFile(inputPath, 'utf-8');
+    const result = compile(source, options);
+    const output = outputPath || inputPath.replace(/\.jps$/, '.js');
+    await fs.promises.writeFile(output, result.code, 'utf-8');
+    // Write source map if enabled
+    if (result.map) {
+        await fs.promises.writeFile(output + '.map', result.map, 'utf-8');
+    }
+}
+/**
+ * Compile multiple files
+ *
+ * @param files - Array of file paths or {input, output} objects
+ * @param options - Compilation options
+ *
+ * @example
+ * ```typescript
+ * await compileFiles([
+ *   { input: 'src/main.jps', output: 'dist/main.js' },
+ *   { input: 'src/util.jps', output: 'dist/util.js' }
+ * ], { format: 'esm' });
+ * ```
+ */
+export async function compileFiles(files, options = {}) {
+    await Promise.all(files.map(file => {
+        if (typeof file === 'string') {
+            return compileFile(file, undefined, options);
+        }
+        else {
+            return compileFile(file.input, file.output, options);
+        }
+    }));
+}
+/**
+ * Simple hash function for caching
+ */
+function hashSource(source) {
+    let hash = 0;
+    for (let i = 0; i < source.length; i++) {
+        const char = source.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return hash.toString(36);
+}
+/**
+ * Batch compile with progress tracking
+ *
+ * @param files - Array of file paths
+ * @param options - Compilation options
+ * @param onProgress - Progress callback
+ *
+ * @example
+ * ```typescript
+ * await batchCompile(
+ *   ['file1.jps', 'file2.jps', 'file3.jps'],
+ *   { format: 'esm' },
+ *   (completed, total) => console.log(`${completed}/${total}`)
+ * );
+ * ```
+ */
+export async function batchCompile(files, options = {}, onProgress) {
+    let completed = 0;
+    const total = files.length;
+    for (const file of files) {
+        await compileFile(file, undefined, options);
+        completed++;
+        if (onProgress) {
+            onProgress(completed, total);
+        }
+    }
+}

package/dist/api/benchmark.d.ts

@@ -0,0 +1,87 @@
+import { CompileOptions } from "./index.js";
+export interface BenchmarkResult {
+    totalTime: number;
+    averageTime: number;
+    minTime: number;
+    maxTime: number;
+    iterations: number;
+    throughput: number;
+}
+/**
+ * Benchmark compilation performance
+ *
+ * @param source - JPS source code to compile
+ * @param options - Compilation options
+ * @param iterations - Number of iterations (default: 100)
+ * @returns Benchmark results
+ *
+ * @example
+ * ```typescript
+ * const result = benchmark('print("Hello")', {}, 1000);
+ * console.log(`Average: ${result.averageTime}ms`);
+ * console.log(`Throughput: ${result.throughput} ops/sec`);
+ * ```
+ */
+export declare function benchmark(source: string, options?: CompileOptions, iterations?: number): BenchmarkResult;
+/**
+ * Compare performance across different options
+ *
+ * @param source - JPS source code
+ * @param optionsArray - Array of options to compare
+ * @param iterations - Number of iterations per test
+ * @returns Array of benchmark results
+ *
+ * @example
+ * ```typescript
+ * const results = comparePerformance(
+ *   'print("test")',
+ *   [
+ *     { format: 'esm', runtimeMode: 'inline' },
+ *     { format: 'esm', runtimeMode: 'external' },
+ *     { format: 'iife', runtimeMode: 'inline' }
+ *   ]
+ * );
+ * ```
+ */
+export declare function comparePerformance(source: string, optionsArray: CompileOptions[], iterations?: number): Array<{
+    options: CompileOptions;
+    result: BenchmarkResult;
+}>;
+/**
+ * Profile compilation stages
+ *
+ * @param source - JPS source code
+ * @param options - Compilation options
+ * @returns Timing for each compilation stage
+ *
+ * @example
+ * ```typescript
+ * const profile = profileCompilation('def foo(): return 42');
+ * console.log(profile);
+ * // {
+ * //   tokenize: 0.5ms,
+ * //   parse: 1.2ms,
+ * //   transform: 0.3ms,
+ * //   generate: 0.8ms,
+ * //   total: 2.8ms
+ * // }
+ * ```
+ */
+export declare function profileCompilation(source: string, options?: CompileOptions): Record<string, number>;
+/**
+ * Memory usage profiling
+ *
+ * @param source - JPS source code
+ * @param options - Compilation options
+ * @returns Memory usage information (if available)
+ */
+export declare function profileMemory(source: string, options?: CompileOptions): {
+    before: number;
+    after: number;
+    delta: number;
+} | null;
+/**
+ * Format benchmark results for display
+ */
+export declare function formatBenchmarkResult(result: BenchmarkResult): string;
+//# sourceMappingURL=benchmark.d.ts.map

package/dist/api/benchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../../src/api/benchmark.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,cAAc,EAAE,MAAM,YAAY,CAAC;AAErD,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,EAC5B,UAAU,GAAE,MAAY,GACvB,eAAe,CA8BjB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,cAAc,EAAE,EAC9B,UAAU,GAAE,MAAY,GACvB,KAAK,CAAC;IAAE,OAAO,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,CAAC,CAK7D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,GAC3B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgCxB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,GAC3B;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAezD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CASrE"}