redscript-mc 1.0.0 → 1.2.0

package/dist/__tests__/e2e.test.js

@@ -124,6 +124,184 @@ fn main() {
             expect(mainFn).toContain('"objective":"rs"');
         });
     });
+    describe('timer builtins', () => {
+        it('generates scheduled timer helper functions', () => {
+            const files = compile(`
+fn main() {
+    let intervalId: int = setInterval(20, () => {
+        say("tick");
+    });
+    setTimeout(100, () => {
+        say("later");
+    });
+    clearInterval(intervalId);
+}
+`);
+            const mainFn = getFunction(files, 'main');
+            const intervalFn = getFunction(files, '__interval_0');
+            const intervalBodyFn = getFunction(files, '__interval_body_0');
+            const timeoutFn = getFunction(files, '__timeout_0');
+            expect(mainFn).toBeDefined();
+            expect(mainFn).toContain('schedule function test:__interval_0 20t');
+            expect(mainFn).toContain('schedule function test:__timeout_0 100t');
+            expect(mainFn).toContain('schedule clear test:__interval_0');
+            expect(intervalFn).toContain('function test:__interval_body_0');
+            expect(intervalFn).toContain('schedule function test:__interval_0 20t');
+            expect(intervalBodyFn).toContain('say tick');
+            expect(timeoutFn).toContain('say later');
+        });
+    });
+    describe('is type narrowing', () => {
+        it('type checks and compiles entity narrowing inside foreach blocks', () => {
+            const source = `
+fn main() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(e);
+        }
+        if (e is Zombie) {
+            kill(e);
+        }
+    }
+}
+`;
+            expect(typeCheck(source)).toEqual([]);
+            const files = compile(source);
+            const mainFn = getFunction(files, 'main');
+            const foreachFn = getSubFunction(files, 'main', 'foreach_0');
+            const thenFiles = files.filter(file => file.path.includes('/main/then_') && file.content.includes('kill @s'));
+            expect(mainFn).toContain('execute as @e run function test:main/foreach_0');
+            expect(foreachFn).toContain('execute if entity @s[type=player] run function test:main/then_');
+            expect(foreachFn).toContain('execute if entity @s[type=zombie] run function test:main/then_');
+            expect(thenFiles).toHaveLength(2);
+        });
+    });
+    describe('impl blocks', () => {
+        it('compiles static and instance impl methods end to end', () => {
+            const source = `
+struct Point { x: int, y: int }
+
+impl Point {
+    fn new(x: int, y: int) -> Point {
+        return { x: x, y: y };
+    }
+
+    fn distance(self) -> int {
+        return self.x + self.y;
+    }
+}
+
+fn main() {
+    let p: Point = Point::new(1, 2);
+    let d: int = p.distance();
+    say("\${d}");
+}
+`;
+            expect(typeCheck(source)).toEqual([]);
+            const files = compile(source);
+            const mainFn = getFunction(files, 'main');
+            const staticFn = getFunction(files, 'Point_new');
+            const instanceFn = getFunction(files, 'Point_distance');
+            expect(mainFn).toContain('function test:Point_new');
+            expect(mainFn).toContain('function test:Point_distance');
+            expect(staticFn).toBeDefined();
+            expect(instanceFn).toBeDefined();
+        });
+    });
+    describe('namespace prefixing', () => {
+        it('prefixes user objectives but preserves mc_name and qualified objectives', () => {
+            const files = compile(`
+fn main() {
+    scoreboard_set("timer", #rs, 100);
+    scoreboard_set(@s, "timer", 100);
+    scoreboard_set(@s, #health, 20);
+    scoreboard_set(@s, "custom.timer", 1);
+}
+`, 'pack');
+            const mainFn = getFunction(files, 'main');
+            expect(mainFn).toContain('scoreboard players set timer rs 100');
+            expect(mainFn).toContain('scoreboard players set @s pack.timer 100');
+            expect(mainFn).toContain('scoreboard players set @s health 20');
+            expect(mainFn).toContain('scoreboard players set @s custom.timer 1');
+        });
+    });
+    describe('Timer OOP API', () => {
+        it('compiles the Timer impl API end to end', () => {
+            const source = `
+struct Timer {
+    _id: int,
+    _duration: int
+}
+
+impl Timer {
+    fn new(duration: int) -> Timer {
+        scoreboard_set("timer_ticks", #rs, 0);
+        scoreboard_set("timer_active", #rs, 0);
+        return { _id: 0, _duration: duration };
+    }
+
+    fn start(self) {
+        scoreboard_set("timer_active", #rs, 1);
+    }
+
+    fn pause(self) {
+        scoreboard_set("timer_active", #rs, 0);
+    }
+
+    fn reset(self) {
+        scoreboard_set("timer_ticks", #rs, 0);
+    }
+
+    fn done(self) -> bool {
+        let ticks: int = scoreboard_get("timer_ticks", #rs);
+        return ticks >= self._duration;
+    }
+
+    fn tick(self) {
+        let active: int = scoreboard_get("timer_active", #rs);
+        let ticks: int = scoreboard_get("timer_ticks", #rs);
+
+        if (active == 1) {
+            if (ticks < self._duration) {
+                scoreboard_set("timer_ticks", #rs, ticks + 1);
+            }
+        }
+    }
+}
+
+fn main() {
+    let t: Timer = Timer::new(100);
+    t.start();
+    t.tick();
+    let finished: bool = t.done();
+    if (finished) {
+        say("done");
+    }
+    t.pause();
+    t.reset();
+}
+`;
+            expect(typeCheck(source)).toEqual([]);
+            const files = compile(source, 'timerapi');
+            const mainFn = getFunction(files, 'main');
+            const newFn = getFunction(files, 'Timer_new');
+            const startFn = getFunction(files, 'Timer_start');
+            const tickFn = getFunction(files, 'Timer_tick');
+            const doneFn = getFunction(files, 'Timer_done');
+            const pauseFn = getFunction(files, 'Timer_pause');
+            const resetFn = getFunction(files, 'Timer_reset');
+            expect(mainFn).toContain('function timerapi:Timer_new');
+            expect(mainFn).toContain('function timerapi:Timer_start');
+            expect(mainFn).toContain('function timerapi:Timer_tick');
+            expect(mainFn).toContain('function timerapi:Timer_done');
+            expect(newFn).toContain('scoreboard players set timer_ticks rs 0');
+            expect(startFn).toContain('scoreboard players set timer_active rs 1');
+            expect(tickFn).toContain('scoreboard players get timer_active rs');
+            expect(doneFn).toContain('scoreboard players get timer_ticks rs');
+            expect(pauseFn).toContain('scoreboard players set timer_active rs 0');
+            expect(resetFn).toContain('scoreboard players set timer_ticks rs 0');
+        });
+    });
     describe('advancement event decorators', () => {
         it('generates advancement json with reward function path', () => {
             const source = `
@@ -276,12 +454,12 @@ fn test() {
 }
 `;
             const fn = getFunction(compile(source), 'test');
-            expect(fn).toContain('scoreboard objectives setdisplay sidebar kills');
-            expect(fn).toContain('scoreboard objectives setdisplay list coins');
-            expect(fn).toContain('scoreboard objectives setdisplay belowName hp');
+            expect(fn).toContain('scoreboard objectives setdisplay sidebar test.kills');
+            expect(fn).toContain('scoreboard objectives setdisplay list test.coins');
+            expect(fn).toContain('scoreboard objectives setdisplay belowName test.hp');
             expect(fn).toContain('scoreboard objectives setdisplay sidebar');
-            expect(fn).toContain('scoreboard objectives add kills playerKillCount "Kill Count"');
-            expect(fn).toContain('scoreboard objectives remove kills');
+            expect(fn).toContain('scoreboard objectives add test.kills playerKillCount "Kill Count"');
+            expect(fn).toContain('scoreboard objectives remove test.kills');
         });
         it('compiles bossbar builtins', () => {
             const source = `
@@ -306,7 +484,7 @@ fn test() {
             expect(fn).toContain('bossbar set ns:health visible true');
             expect(fn).toContain('bossbar set ns:health players @a');
             expect(fn).toContain('bossbar remove ns:health');
-            expect(fn).toMatch(/execute store result score \$t\d+ rs run bossbar get ns:health value/);
+            expect(fn).toMatch(/execute store result score \$_\d+ rs run bossbar get ns:health value/);
         });
         it('compiles team builtins', () => {
             const source = `
@@ -485,7 +663,7 @@ fn test() -> int {
             const fn = getFunction(files, 'test');
             expect(fn).toBeDefined();
             expect(fn).toContain('execute store result score');
-            expect(fn).toContain('scoreboard players get PlayerName kill_count');
+            expect(fn).toContain('scoreboard players get PlayerName test.kill_count');
         });
         it('compiles scoreboard_get with @s selector', () => {
             const source = `
@@ -497,7 +675,7 @@ fn test() -> int {
             const files = compile(source);
             const fn = getFunction(files, 'test');
             expect(fn).toBeDefined();
-            expect(fn).toContain('scoreboard players get @s kill_count');
+            expect(fn).toContain('scoreboard players get @s test.kill_count');
         });
         it('compiles scoreboard_set with constant value', () => {
             const source = `
@@ -508,7 +686,7 @@ fn test() {
             const files = compile(source);
             const fn = getFunction(files, 'test');
             expect(fn).toBeDefined();
-            expect(fn).toContain('scoreboard players set PlayerName kill_count 100');
+            expect(fn).toContain('scoreboard players set PlayerName test.kill_count 100');
         });
         it('compiles scoreboard_set with variable value', () => {
             const source = `
@@ -522,7 +700,7 @@ fn test() {
                 .filter(f => f.path.includes('test'))
                 .map(f => f.content)
                 .join('\n');
-            expect(allContent).toContain('execute store result score @s score');
+            expect(allContent).toContain('execute store result score @s test.score');
         });
         it('compiles score() as expression', () => {
             const source = `
@@ -548,7 +726,7 @@ fn double_score() -> int {
             const files = compile(source);
             const fn = getFunction(files, 'double_score');
             expect(fn).toBeDefined();
-            expect(fn).toContain('scoreboard players get @s points');
+            expect(fn).toContain('scoreboard players get @s test.points');
         });
     });
     describe('Built-in functions', () => {
@@ -586,19 +764,19 @@ fn double_score() -> int {
             const source = 'fn test() { let x: int = random(1, 10); }';
             const files = compile(source);
             const fn = getFunction(files, 'test');
-            expect(fn).toContain('scoreboard players random $t0 rs 1 10');
+            expect(fn).toContain('scoreboard players random $_0 rs 1 10');
         });
         it('compiles random_native()', () => {
             const source = 'fn test() { let x: int = random_native(1, 6); }';
             const files = compile(source);
             const fn = getFunction(files, 'test');
-            expect(fn).toContain('execute store result score $t0 rs run random value 1 6');
+            expect(fn).toContain('execute store result score $_0 rs run random value 1 6');
         });
         it('compiles random_native() with zero min', () => {
             const source = 'fn test() { let x: int = random_native(0, 100); }';
             const files = compile(source);
             const fn = getFunction(files, 'test');
-            expect(fn).toContain('execute store result score $t0 rs run random value 0 100');
+            expect(fn).toContain('execute store result score $_0 rs run random value 0 100');
         });
         it('compiles random_sequence()', () => {
             const source = 'fn test() { random_sequence("loot"); random_sequence("loot", 9); }';
@@ -1079,7 +1257,7 @@ fn handle_claim() {
             expect(fn).toContain('if entity @s[tag=boss]');
         });
     });
-    describe('Real program: zombie_game.rs', () => {
+    describe('Real program: zombie_game.mcrs', () => {
         const source = `
 // A zombie survival game logic
 // Kills nearby zombies and tracks score
@@ -1342,10 +1520,10 @@ fn heal(amount: int) {
     });
     describe('backward compat: string objective still works', () => {
         const source = `fn test() { let x: int = scoreboard_get(@s, "kills"); }`;
-        it('compiles "kills" string to bare objective name', () => {
+        it('prefixes plain string objectives with the active namespace', () => {
             const files = compile(source, 'compat');
             const fn = getFunction(files, 'test');
-            expect(fn).toContain('scoreboard players get @s kills');
+            expect(fn).toContain('scoreboard players get @s compat.kills');
         });
     });
     describe('#mc_name with fake player target', () => {
@@ -1525,4 +1703,145 @@ describe('for-range loop', () => {
         expect(subFn?.content).toContain('execute if score $x rs matches ..7 run function forloop2:test/__for_0');
     });
 });
+// ---------------------------------------------------------------------------
+// NBT Structured Parameters
+// ---------------------------------------------------------------------------
+describe('NBT parameters', () => {
+    it('compiles give with NBT struct', () => {
+        const src = `fn test() { give(@s, "minecraft:diamond_sword", 1, { display: { Name: "Excalibur" } }); }`;
+        const files = compile(src, 'nbtparam');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('give @s minecraft:diamond_sword{display:{Name:"Excalibur"}} 1');
+    });
+    it('compiles give with nested NBT and arrays', () => {
+        const src = `fn test() { give(@s, "minecraft:stick", 1, { display: { Name: "Magic Wand" }, Enchantments: [{ id: "sharpness", lvl: 5 }] }); }`;
+        const files = compile(src, 'nbtparam2');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('{display:{Name:"Magic Wand"},Enchantments:[{id:"sharpness",lvl:5}]}');
+    });
+    it('compiles summon with NBT', () => {
+        const src = `fn test() { summon("minecraft:zombie", 0, 64, 0, { CustomName: "Boss", NoAI: true }); }`;
+        const files = compile(src, 'nbtsummon');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('summon minecraft:zombie 0 64 0 {CustomName:"Boss",NoAI:1b}');
+    });
+    it('compiles give with bool values in NBT', () => {
+        const src = `fn test() { give(@s, "minecraft:shield", 1, { Unbreakable: true }); }`;
+        const files = compile(src, 'nbtbool');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('{Unbreakable:1b}');
+    });
+});
+// ---------------------------------------------------------------------------
+// Set Operations
+// ---------------------------------------------------------------------------
+describe('Set operations', () => {
+    it('creates a new set', () => {
+        const src = `fn test() { let s = set_new(); }`;
+        const files = compile(src, 'settest');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('data modify storage rs:sets __set_0 set value []');
+    });
+    it('adds to a set with uniqueness check', () => {
+        const src = `fn test() { let s = set_new(); set_add(s, "apple"); }`;
+        const files = compile(src, 'setadd');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('execute unless data storage rs:sets __set_0[{value:apple}] run data modify storage rs:sets __set_0 append value {value:apple}');
+    });
+    it('checks set membership', () => {
+        const src = `fn test() { let s = set_new(); set_add(s, "x"); let has = set_contains(s, "x"); }`;
+        const files = compile(src, 'setcontains');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('if data storage rs:sets __set_0[{value:x}]');
+    });
+    it('removes from a set', () => {
+        const src = `fn test() { let s = set_new(); set_add(s, "y"); set_remove(s, "y"); }`;
+        const files = compile(src, 'setremove');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('data remove storage rs:sets __set_0[{value:y}]');
+    });
+    it('clears a set', () => {
+        const src = `fn test() { let s = set_new(); set_clear(s); }`;
+        const files = compile(src, 'setclear');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('data modify storage rs:sets __set_0 set value []');
+    });
+});
+// ---------------------------------------------------------------------------
+// Method Syntax Sugar
+// ---------------------------------------------------------------------------
+describe('Method syntax sugar', () => {
+    it('transforms obj.method() to method(obj)', () => {
+        const src = `fn test() { let s = set_new(); s.clear(); }`;
+        const files = compile(src, 'method1');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('data modify storage rs:sets __set_0 set value []');
+    });
+    it('transforms obj.method(arg) to method(obj, arg)', () => {
+        const src = `fn test() { let s = set_new(); s.add("apple"); }`;
+        const files = compile(src, 'method2');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('data modify storage rs:sets __set_0 append value {value:apple}');
+    });
+    it('transforms obj.method(arg) with contains', () => {
+        const src = `fn test() { let s = set_new(); s.add("x"); let r = s.contains("x"); }`;
+        const files = compile(src, 'method3');
+        const fn = getFunction(files, 'test');
+        expect(fn).toBeDefined();
+    });
+    it('works with multiple args', () => {
+        const src = `fn test() { let s = set_new(); s.add("a"); s.add("b"); s.remove("a"); }`;
+        const files = compile(src, 'method4');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('data remove storage rs:sets __set_0[{value:a}]');
+    });
+});
+describe('Global variables', () => {
+    it('initializes global in __load', () => {
+        const src = `let x: int = 42;\nfn test() { say("hi"); }`;
+        const files = compile(src, 'globaltest');
+        const load = getFunction(files, '__load');
+        expect(load).toContain('scoreboard players set $x rs 42');
+    });
+    it('reads and writes global in function', () => {
+        const src = `let count: int = 0;\nfn inc() { count = count + 1; }`;
+        const files = compile(src, 'globalrw');
+        const fn = getFunction(files, 'inc');
+        expect(fn).toBeDefined();
+        // Global should be initialized in __load
+        const load = getFunction(files, '__load');
+        expect(load).toContain('scoreboard players set $count rs 0');
+    });
+    it('const cannot be reassigned', () => {
+        const src = `const X: int = 5;\nfn bad() { X = 10; }`;
+        expect(() => compile(src, 'constbad')).toThrow();
+    });
+});
+describe('@load decorator', () => {
+    it('calls @load function from __load.mcfunction', () => {
+        const src = `@load fn init() { say("Datapack loaded!"); }`;
+        const files = compile(src, 'loadtest');
+        const load = getFunction(files, '__load');
+        expect(load).toContain('function loadtest:init');
+    });
+    it('calls multiple @load functions in order', () => {
+        const src = `
+      @load fn setup() { say("setup"); }
+      @load fn init() { say("init"); }
+    `;
+        const files = compile(src, 'loadtest');
+        const load = getFunction(files, '__load');
+        const setupIdx = load.indexOf('function loadtest:setup');
+        const initIdx = load.indexOf('function loadtest:init');
+        expect(setupIdx).toBeGreaterThan(-1);
+        expect(initIdx).toBeGreaterThan(-1);
+        expect(setupIdx).toBeLessThan(initIdx);
+    });
+    it('generates the @load function body normally', () => {
+        const src = `@load fn init() { say("hi"); }`;
+        const files = compile(src, 'loadtest');
+        const fn = getFunction(files, 'init');
+        expect(fn).toContain('say hi');
+    });
+});
 //# sourceMappingURL=e2e.test.js.map

package/dist/__tests__/formatter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/formatter.test.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const formatter_1 = require("../formatter");
+describe('formatter', () => {
+    it('normalizes indentation to 4 spaces', () => {
+        const input = 'fn main() {\n  let x: int = 1;\n}';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn main() {\n    let x: int = 1;\n}\n');
+    });
+    it('handles nested blocks', () => {
+        const input = 'fn main() {\nif true {\nlet x: int = 1;\n}\n}';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn main() {\n    if true {\n        let x: int = 1;\n    }\n}\n');
+    });
+    it('trims trailing whitespace', () => {
+        const input = 'fn main() {   \n    let x: int = 1;   \n}   ';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn main() {\n    let x: int = 1;\n}\n');
+    });
+    it('ensures single newline at end of file', () => {
+        const input = 'fn main() {\n}\n\n\n';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn main() {\n}\n');
+    });
+    it('preserves blank lines', () => {
+        const input = 'fn a() {\n}\n\nfn b() {\n}';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn a() {\n}\n\nfn b() {\n}\n');
+    });
+    it('handles already formatted code', () => {
+        const input = 'fn main() {\n    let x: int = 1;\n}\n';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe(input);
+    });
+    it('handles empty input', () => {
+        expect((0, formatter_1.format)('')).toBe('\n');
+        expect((0, formatter_1.format)('\n\n')).toBe('\n');
+    });
+});
+//# sourceMappingURL=formatter.test.js.map

package/dist/__tests__/lexer.test.js

@@ -10,10 +10,16 @@ function kinds(tokens) {
 describe('Lexer', () => {
     describe('keywords', () => {
         it('recognizes all keywords', () => {
-            const tokens = tokenize('fn let const if else while for foreach match return as at in struct enum trigger namespace');
+            const tokens = tokenize('fn let const if else while for foreach match return as at in is struct impl enum trigger namespace');
             expect(kinds(tokens)).toEqual([
                 'fn', 'let', 'const', 'if', 'else', 'while', 'for', 'foreach', 'match',
-                'return', 'as', 'at', 'in', 'struct', 'enum', 'trigger', 'namespace', 'eof'
+                'return', 'as', 'at', 'in', 'is', 'struct', 'impl', 'enum', 'trigger', 'namespace', 'eof'
+            ]);
+        });
+        it('tokenizes is-check and impl syntax with their dedicated keywords', () => {
+            const tokens = tokenize('if (e is Player) { } impl Point { }');
+            expect(kinds(tokens)).toEqual([
+                'if', '(', 'ident', 'is', 'ident', ')', '{', '}', 'impl', 'ident', '{', '}', 'eof',
             ]);
         });
         it('recognizes type keywords', () => {
@@ -169,6 +175,10 @@ describe('Lexer', () => {
             const tokens = tokenize('=>');
             expect(kinds(tokens)).toEqual(['=>', 'eof']);
         });
+        it('tokenizes static method separators for impl methods', () => {
+            const tokens = tokenize('Point::new()');
+            expect(kinds(tokens)).toEqual(['ident', '::', 'ident', '(', ')', 'eof']);
+        });
     });
     describe('delimiters', () => {
         it('tokenizes all delimiters', () => {