redscript-mc 1.2.30 → 2.0.0

package/dist/src/repl.d.ts

@@ -0,0 +1,16 @@
+import type { DatapackFile } from '../src2/emit/index';
+export interface ReplEvaluation {
+    source: string;
+    files: DatapackFile[];
+    output: string;
+}
+export declare class ReplSession {
+    private readonly namespace;
+    private declarations;
+    private statements;
+    constructor(namespace?: string);
+    clear(): void;
+    getSource(): string;
+    evaluate(input: string): ReplEvaluation;
+}
+export declare function startRepl(namespace?: string): Promise<void>;

package/dist/src/repl.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplSession = void 0;
+exports.startRepl = startRepl;
+const readline = __importStar(require("readline"));
+const index_1 = require("./index");
+const REPL_FN = '__repl';
+class ReplSession {
+    constructor(namespace = 'repl') {
+        this.namespace = namespace;
+        this.declarations = [];
+        this.statements = [];
+    }
+    clear() {
+        this.declarations = [];
+        this.statements = [];
+    }
+    getSource() {
+        const sections = [];
+        if (this.declarations.length > 0) {
+            sections.push(this.declarations.join('\n\n'));
+        }
+        const body = this.statements.map(stmt => `  ${stmt}`).join('\n');
+        sections.push(`fn ${REPL_FN}() {\n${body}${body ? '\n' : ''}}`);
+        return sections.join('\n\n');
+    }
+    evaluate(input) {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            return { source: this.getSource(), files: [], output: '' };
+        }
+        const declaration = isTopLevelDeclaration(trimmed);
+        const normalized = declaration ? trimmed : normalizeStatement(trimmed);
+        const nextDeclarations = declaration ? [...this.declarations, normalized] : [...this.declarations];
+        const nextStatements = declaration ? [...this.statements] : [...this.statements, normalized];
+        const source = buildSource(nextDeclarations, nextStatements);
+        const result = (0, index_1.compile)(source, { namespace: this.namespace });
+        const files = selectRelevantFiles(result.files, this.namespace, declaration);
+        this.declarations = nextDeclarations;
+        this.statements = nextStatements;
+        return {
+            source,
+            files,
+            output: formatFiles(files, declaration),
+        };
+    }
+}
+exports.ReplSession = ReplSession;
+async function startRepl(namespace = 'repl') {
+    const session = new ReplSession(namespace);
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+    });
+    console.log('RedScript REPL. Type :help for commands.');
+    try {
+        while (true) {
+            const line = await question(rl, 'rs> ');
+            const trimmed = line.trim();
+            if (trimmed === ':quit') {
+                break;
+            }
+            if (trimmed === ':help') {
+                console.log([
+                    'Commands:',
+                    '  :help  Show REPL commands',
+                    '  :clear Reset declarations and statements',
+                    '  :quit  Exit the REPL',
+                ].join('\n'));
+                continue;
+            }
+            if (trimmed === ':clear') {
+                session.clear();
+                console.log('State cleared.');
+                continue;
+            }
+            try {
+                const evaluation = session.evaluate(line);
+                if (evaluation.output) {
+                    console.log(evaluation.output);
+                }
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+function question(rl, prompt) {
+    return new Promise(resolve => rl.question(prompt, resolve));
+}
+function buildSource(declarations, statements) {
+    const sections = [];
+    if (declarations.length > 0) {
+        sections.push(declarations.join('\n\n'));
+    }
+    const body = statements.map(stmt => `  ${stmt}`).join('\n');
+    sections.push(`fn ${REPL_FN}() {\n${body}${body ? '\n' : ''}}`);
+    return sections.join('\n\n');
+}
+function isTopLevelDeclaration(line) {
+    return /^(?:@\w+(?:\([^)]*\))?\s*)*(fn|struct|enum)\b/.test(line);
+}
+function normalizeStatement(line) {
+    if (/[;}]$/.test(line)) {
+        return line;
+    }
+    return `${line};`;
+}
+function selectRelevantFiles(files, namespace, declaration) {
+    if (declaration) {
+        const functionFiles = files.filter(file => file.path.startsWith(`data/${namespace}/function/`) &&
+            file.path.endsWith('.mcfunction') &&
+            !file.path.includes(`/${REPL_FN}/`) &&
+            !file.path.endsWith('/__load.mcfunction') &&
+            !file.path.endsWith('/__tick.mcfunction'));
+        return functionFiles;
+    }
+    return files.filter(file => file.path.startsWith(`data/${namespace}/function/${REPL_FN}`) &&
+        file.path.endsWith('.mcfunction'));
+}
+function formatFiles(files, declaration) {
+    if (files.length === 0) {
+        return declaration ? 'Accepted. No mcfunction output for this declaration yet.' : '';
+    }
+    return files.map(file => `${file.path}\n${file.content}`).join('\n\n');
+}
+//# sourceMappingURL=repl.js.map

package/dist/src/runtime/index.d.ts

@@ -0,0 +1,107 @@
+/**
+ * MCRuntime - Minecraft Command Runtime Simulator
+ *
+ * A TypeScript interpreter that simulates the subset of MC commands that
+ * RedScript generates, allowing behavioral testing without a real server.
+ */
+export interface Entity {
+    id: string;
+    tags: Set<string>;
+    scores: Map<string, number>;
+    selector: string;
+    type?: string;
+    position?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+interface Range {
+    min: number;
+    max: number;
+}
+declare function parseRange(s: string): Range;
+declare function matchesRange(value: number, range: Range): boolean;
+declare function parseSelector(sel: string, entities: Entity[], executor?: Entity): Entity[];
+export declare class MCRuntime {
+    scoreboard: Map<string, Map<string, number>>;
+    storage: Map<string, any>;
+    entities: Entity[];
+    functions: Map<string, string[]>;
+    chatLog: string[];
+    world: Map<string, string>;
+    weather: string;
+    worldTime: number;
+    effects: Map<string, {
+        effect: string;
+        duration: number;
+        amplifier: number;
+    }[]>;
+    xp: Map<string, number>;
+    tickCount: number;
+    namespace: string;
+    private entityIdCounter;
+    private returnValue;
+    private shouldReturn;
+    private currentMacroContext;
+    constructor(namespace: string);
+    loadDatapack(dir: string): void;
+    loadFunction(name: string, lines: string[]): void;
+    load(): void;
+    tick(): void;
+    ticks(n: number): void;
+    execFunction(name: string, executor?: Entity): void;
+    private execFunctionLines;
+    execCommand(cmd: string, executor?: Entity): boolean;
+    private execScoreboard;
+    private execExecute;
+    private parseNextSelector;
+    private execFunctionCmd;
+    /** Expand MC macro placeholders: $(key) → value from currentMacroContext */
+    private expandMacro;
+    private execData;
+    private parseDataValue;
+    /** Return the whole storage compound at storagePath as a flat key→value map.
+     *  Used by 'function ... with storage' to provide macro context. */
+    private getStorageCompound;
+    private getStorageField;
+    private setStorageField;
+    private removeStorageField;
+    private parseStoragePath;
+    private execTag;
+    private execSay;
+    private execTellraw;
+    private execTitle;
+    private extractJsonText;
+    private execSetblock;
+    private execFill;
+    private execTp;
+    private execWeather;
+    private execTime;
+    private execKill;
+    private execEffect;
+    private execXp;
+    private execSummon;
+    private execReturn;
+    getScore(player: string, objective: string): number;
+    setScore(player: string, objective: string, value: number): void;
+    addScore(player: string, objective: string, delta: number): void;
+    getStorage(path: string): any;
+    setStorage(path: string, value: any): void;
+    spawnEntity(tags: string[], type?: string, position?: {
+        x: number;
+        y: number;
+        z: number;
+    }): Entity;
+    killEntity(tag: string): void;
+    getEntities(selector: string): Entity[];
+    private positionKey;
+    private parseAbsolutePosition;
+    private resolvePosition;
+    private parseTimeValue;
+    private resolveTargetKeys;
+    getLastSaid(): string;
+    getChatLog(): string[];
+    compileAndLoad(source: string): void;
+}
+export { parseRange, matchesRange, parseSelector };