Fixed another subtle server related bug

Added optional capturing to scripts

1 files changed, 50 insertions, 13 deletions

diff --git a/src/fields/ScriptField.ts b/src/fields/ScriptField.ts
index 24c1d9b3a..34c8a7544 100644
--- a/src/fields/ScriptField.ts
+++ b/src/fields/ScriptField.ts
@@ -2,33 +2,34 @@ import { Field, FieldId } from "./Field";
 import { Types } from "../server/Message";
 import { CompileScript, ScriptOptions, CompiledScript } from "../client/util/Scripting";
 import { Server } from "../client/Server";
+import { Without } from "../Utils";
+
+export interface SerializableOptions extends Without<ScriptOptions, "capturedVariables"> {
+    capturedIds: { [id: string]: string };
+}
 
 export interface ScriptData {
     script: string;
-    options: ScriptOptions;
+    options: SerializableOptions;
 }
 
 export class ScriptField extends Field {
-    readonly script: CompiledScript;
+    private _script?: CompiledScript;
+    get script(): CompiledScript {
+        return this._script!;
+    }
+    private options?: ScriptData;
 
-    constructor(script: CompiledScript, id?: FieldId, save: boolean = true) {
+    constructor(script?: CompiledScript, id?: FieldId, save: boolean = true) {
         super(id);
 
-        this.script = script;
+        this._script = script;
 
         if (save) {
             Server.UpdateField(this);
         }
     }
 
-    static FromJson(id: string, data: ScriptData): ScriptField {
-        const script = CompileScript(data.script, data.options);
-        if (!script.compiled) {
-            throw new Error("Can't compile script");
-        }
-        return new ScriptField(script, id, false);
-    }
-
     ToScriptString() {
         return "new ScriptField(...)";
     }
@@ -45,14 +46,50 @@ export class ScriptField extends Field {
         throw new Error("Script fields currently can't be updated");
     }
 
+    static FromJson(id: string, data: ScriptData): ScriptField {
+        let field = new ScriptField(undefined, id, false);
+        field.options = data;
+        return field;
+    }
+
+    init(callback: (res: Field) => any) {
+        const options = this.options!;
+        const keys = Object.keys(options.options.capturedIds);
+        Server.GetFields(keys).then(fields => {
+            let captured: { [name: string]: Field } = {};
+            keys.forEach(key => captured[options.options.capturedIds[key]] = fields[key]);
+            const opts: ScriptOptions = {
+                addReturn: options.options.addReturn,
+                params: options.options.params,
+                requiredType: options.options.requiredType,
+                capturedVariables: captured
+            };
+            const script = CompileScript(options.script, opts);
+            if (!script.compiled) {
+                throw new Error("Can't compile script");
+            }
+            this._script = script;
+            callback(this);
+        });
+    }
+
     ToJson(): { _id: string, type: Types, data: ScriptData } {
         const { options, originalScript } = this.script;
+        let capturedIds: { [id: string]: string } = {};
+        for (const capt in options.capturedVariables) {
+            capturedIds[options.capturedVariables[capt].Id] = capt;
+        }
+        const opts: SerializableOptions = {
+            ...options,
+            capturedIds
+        };
+        delete (opts as any).capturedVariables;
         return {
             _id: this.Id,
             type: Types.Script,
             data: {
                 script: originalScript,
-                options
+                options: opts,
             },
         };
     }