@tokens-studio/tokenscript-interpreter 0.33.0 → 0.36.0

package/dist/cli.js

@@ -12,7 +12,7 @@ import * as readlineSync from 'readline-sync';
 
 // package.json
 var package_default = {
-  version: "0.32.0"};
+  version: "0.35.0"};
 
 // src/types.ts
 var SupportedFormats = /* @__PURE__ */ ((SupportedFormats2) => {
@@ -151,6 +151,13 @@ var StringNode = class {
     this.value = token.value;
   }
 };
+var TemplateStringNode = class {
+  constructor(parts, token) {
+    this.parts = parts;
+    this.token = token;
+    this.nodeType = "TemplateStringNode";
+  }
+};
 var UnaryOpNode = class {
   constructor(opToken, expr, token) {
     this.opToken = opToken;
@@ -398,6 +405,10 @@ function walkAST(node, onVisit) {
     for (const statement of node.statements) {
       walkAST(statement, onVisit);
     }
+  } else if (node instanceof TemplateStringNode) {
+    for (const part of node.parts) {
+      walkAST(part, onVisit);
+    }
   } else if (node instanceof AttributeAccessNode) {
     walkAST(node.left, onVisit);
     if (node.right instanceof FunctionCallNode || node.right instanceof PartialFunctionCallNode) {
@@ -2548,6 +2559,51 @@ var Lexer = class {
       endPos: this.pos
     };
   }
+  /**
+   * Read a backtick-delimited template string.
+   * Supports escape sequences: \{ \$ \` \\
+   * The raw content (with escapes preserved) is stored as the token value.
+   * The parser handles splitting into segments.
+   */
+  templateString() {
+    const startPos = this.pos;
+    this.eat("`");
+    let result = "";
+    while (this.currentChar !== null && this.currentChar !== "`") {
+      if (this.currentChar === "\\") {
+        const next = this.peek();
+        if (next === "{" || next === "$" || next === "`" || next === "\\") {
+          result += "\\";
+          result += next;
+          this.advance();
+          this.advance();
+          continue;
+        }
+      }
+      result += this.currentChar;
+      this.advance();
+    }
+    if (this.currentChar === null) {
+      if (this.tolerant) {
+        return {
+          type: "TEMPLATE_STRING" /* TEMPLATE_STRING */,
+          value: result,
+          line: this.line,
+          pos: startPos,
+          endPos: this.pos
+        };
+      }
+      this.error("LEXER_UNTERMINATED_TEMPLATE_STRING" /* UNTERMINATED_TEMPLATE_STRING */, {});
+    }
+    this.eat("`");
+    return {
+      type: "TEMPLATE_STRING" /* TEMPLATE_STRING */,
+      value: result,
+      line: this.line,
+      pos: startPos,
+      endPos: this.pos
+    };
+  }
   hexColor() {
     const startPos = this.pos;
     let result = "";
@@ -2598,6 +2654,9 @@ var Lexer = class {
       if (this.currentChar === "'" || this.currentChar === '"') {
         return this.collectToken(this.explicitString(this.currentChar));
       }
+      if (this.currentChar === "`") {
+        return this.collectToken(this.templateString());
+      }
       if (this.isValidIdentifierStart(this.currentChar)) {
         return this.collectToken(this.stringElement());
       }
@@ -2974,7 +3033,7 @@ var Lexer = class {
 };
 
 // src/interpreter/parser.ts
-var Parser = class {
+var Parser = class _Parser {
   constructor(lexer, options) {
     this.requiredReferences = /* @__PURE__ */ new Set();
     this.incompleteInfo = [];
@@ -3420,7 +3479,9 @@ ${contextText}`;
   factor() {
     const token = this.currentToken;
     if (token.type === "LBLOCK" /* LBLOCK */) {
-      return this.explicitList();
+      let node = this.explicitList();
+      node = this.attributeAccess(node);
+      return node;
     }
     if (token.type === "OPERATION" /* OPERATION */ && (token.value === "+" /* ADD */ || token.value === "-" /* SUBTRACT */ || token.value === "!" /* LOGIC_NOT */)) {
       this.eat("OPERATION" /* OPERATION */);
@@ -3436,11 +3497,15 @@ ${contextText}`;
     }
     if (token.type === "RESERVED_KEYWORD" /* RESERVED_KEYWORD */ && (token.value === "true" /* TRUE */ || token.value === "false" /* FALSE */)) {
       this.eat("RESERVED_KEYWORD" /* RESERVED_KEYWORD */);
-      return new BooleanNode(token.value === "true" /* TRUE */, token);
+      let boolNode = new BooleanNode(token.value === "true" /* TRUE */, token);
+      boolNode = this.attributeAccess(boolNode);
+      return boolNode;
     }
     if (token.type === "RESERVED_KEYWORD" /* RESERVED_KEYWORD */ && token.value === "null" /* NULL */) {
       this.eat("RESERVED_KEYWORD" /* RESERVED_KEYWORD */);
-      return new NullNode(token);
+      let nullNode = new NullNode(token);
+      nullNode = this.attributeAccess(nullNode);
+      return nullNode;
     }
     if (token.type === "NUMBER" /* NUMBER */) {
       return this.number();
@@ -3467,7 +3532,7 @@ ${contextText}`;
       if (this.currentToken.type === "FORMAT" /* FORMAT */) {
         return this.format(node);
       }
-      return node;
+      return this.attributeAccess(node);
     }
     if (token.type === "PARTIAL_REFERENCE" /* PARTIAL_REFERENCE */) {
       let node = this.reference();
@@ -3481,7 +3546,9 @@ ${contextText}`;
     }
     if (token.type === "HEX_COLOR" /* HEX_COLOR */) {
       this.eat("HEX_COLOR" /* HEX_COLOR */);
-      return new HexColorNode(token);
+      let hexNode = new HexColorNode(token);
+      hexNode = this.attributeAccess(hexNode);
+      return hexNode;
     }
     if (token.type === "PARTIAL_STRING" /* PARTIAL_STRING */) {
       this.eat("PARTIAL_STRING" /* PARTIAL_STRING */);
@@ -3506,6 +3573,9 @@ ${contextText}`;
       node = this.attributeAccess(node);
       return node;
     }
+    if (token.type === "TEMPLATE_STRING" /* TEMPLATE_STRING */) {
+      return this.templateString();
+    }
     if (token.type === "EXPLICIT_STRING" /* EXPLICIT_STRING */) {
       this.eat("EXPLICIT_STRING" /* EXPLICIT_STRING */);
       let node = new StringNode(token);
@@ -3565,6 +3635,122 @@ ${contextText}`;
     this.eat("RPAREN" /* RPAREN */);
     return new FunctionCallNode(functionName.value, args, functionName);
   }
+  /**
+   * Parse a TEMPLATE_STRING token into a TemplateStringNode.
+   * Scans the raw content for:
+   *   - {ref.path} → ReferenceNode
+   *   - ${expression} → parsed sub-expression
+   *   - \{ \${ \` \\ → escaped literals (backslash removed)
+   *   - everything else → literal StringNode segments
+   */
+  templateString() {
+    const token = this.currentToken;
+    const raw = token.value;
+    this.eat("TEMPLATE_STRING" /* TEMPLATE_STRING */);
+    const parts = [];
+    let literal = "";
+    let i = 0;
+    const flushLiteral = () => {
+      if (literal.length > 0) {
+        parts.push(new StringNode({ ...token, value: literal }));
+        literal = "";
+      }
+    };
+    while (i < raw.length) {
+      const ch = raw[i];
+      if (ch === "\\" && i + 1 < raw.length) {
+        const next = raw[i + 1];
+        if (next === "{" || next === "`" || next === "\\") {
+          literal += next;
+          i += 2;
+          continue;
+        }
+        if (next === "$") {
+          if (i + 2 < raw.length && raw[i + 2] === "{") {
+            literal += "${";
+            i += 3;
+          } else {
+            literal += "$";
+            i += 2;
+          }
+          continue;
+        }
+      }
+      if (ch === "$" && i + 1 < raw.length && raw[i + 1] === "{") {
+        flushLiteral();
+        const start = i + 2;
+        let depth = 1;
+        let j = start;
+        while (j < raw.length && depth > 0) {
+          if (raw[j] === "`") {
+            this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
+              message: "Nested template strings are not allowed inside ${...}"
+            });
+          }
+          if (raw[j] === "{") depth++;
+          else if (raw[j] === "}") depth--;
+          if (depth > 0) j++;
+        }
+        if (depth !== 0) {
+          this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
+            message: "Unterminated ${...} in template string"
+          });
+        }
+        const exprStr = raw.slice(start, j);
+        const subLexer = new Lexer(exprStr);
+        const subParser = new _Parser(subLexer);
+        const exprNode = subParser.expr();
+        for (const ref of subParser.requiredReferences) {
+          this.requiredReferences.add(ref);
+        }
+        parts.push(exprNode);
+        i = j + 1;
+        continue;
+      }
+      if (ch === "{") {
+        flushLiteral();
+        const start = i + 1;
+        let j = start;
+        while (j < raw.length && raw[j] !== "}") {
+          if (raw[j] === "{") {
+            this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
+              message: "Nested braces in template reference"
+            });
+          }
+          j++;
+        }
+        if (j >= raw.length) {
+          this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
+            message: "Unterminated {ref} in template string"
+          });
+        }
+        let refPath = raw.slice(start, j);
+        refPath = refPath.replace(/[ \t]/g, "");
+        if (refPath.length === 0) {
+          this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
+            message: "Empty reference in template string"
+          });
+        }
+        this.requiredReferences.add(refPath);
+        parts.push(
+          new ReferenceNode({
+            ...token,
+            type: "REFERENCE" /* REFERENCE */,
+            value: refPath
+          })
+        );
+        i = j + 1;
+        continue;
+      }
+      literal += ch;
+      i++;
+    }
+    flushLiteral();
+    if (parts.length === 1 && parts[0] instanceof StringNode) {
+      return parts[0];
+    }
+    return new TemplateStringNode(parts, token);
+  }
   parse(inlineMode = false) {
     if (this.tolerant && !inlineMode) {
       this.error("PARSER_TOLERANT_REQUIRES_INLINE" /* TOLERANT_REQUIRES_INLINE */);
@@ -8215,6 +8401,47 @@ var Interpreter = class {
   visitStringNode(node) {
     return new StringSymbol(node.value, this.config);
   }
+  visitTemplateStringNode(node) {
+    if (node.parts.length === 0) {
+      return new StringSymbol("", this.config);
+    }
+    if (node.parts.length === 1) {
+      const val = this.visit(node.parts[0]);
+      this.validateTemplateValue(val, node);
+      return val;
+    }
+    let result = "";
+    for (const part of node.parts) {
+      const val = this.visit(part);
+      this.validateTemplateValue(val, node);
+      result += val.toString();
+    }
+    return new StringSymbol(result, this.config);
+  }
+  /**
+   * Validate that a value is a primitive type allowed in template string interpolation.
+   * Lists, Dictionaries, and non-hex Colors are rejected.
+   */
+  validateTemplateValue(val, node) {
+    if (val instanceof ListSymbol) {
+      throw new InterpreterError("INT_TEMPLATE_INVALID_TYPE" /* TEMPLATE_INVALID_TYPE */, {
+        token: node.token,
+        data: { valueType: "List" }
+      });
+    }
+    if (val instanceof DictionarySymbol) {
+      throw new InterpreterError("INT_TEMPLATE_INVALID_TYPE" /* TEMPLATE_INVALID_TYPE */, {
+        token: node.token,
+        data: { valueType: "Dictionary" }
+      });
+    }
+    if (val instanceof ColorSymbol && !val.isHex()) {
+      throw new InterpreterError("INT_TEMPLATE_INVALID_TYPE" /* TEMPLATE_INVALID_TYPE */, {
+        token: node.token,
+        data: { valueType: `Color.${val.subType}` }
+      });
+    }
+  }
   /**
    * Bare identifiers are treated as string literals if not found as variables
    * Check symbol table first (variables override references), then references