@tokens-studio/tokenscript-interpreter 0.32.0 → 0.34.0

package/dist/lib/{chunk-UYVHWJIC.js → chunk-RWXDOZAS.js}

@@ -1,5 +1,5 @@
-import { DictionarySymbol, serializeInterpreterResult, stringifyInterpreterResult, isSome, LexerError, isSpace, isNumber2, isAlpha, isAlphaNumeric, ParserError, isLanguageError, NullSymbol, isTokenscriptSymbol, StringSymbol, NumberWithUnitSymbol, NumberSymbol, InterpreterError, BooleanSymbol, isNull, jsValueToSymbolType, ListSymbol, parseHexWithAlpha, ColorSymbol, basicSymbolTypes, typeName, typeEquals, ProcessorError, isObject, TokenSymbol, isArray, isString, getKeyAlt, isNumber, isBoolean, safeParseInt, serializeError, ensureValidAlpha, formatHex8, isTransparent, getResultTypeName, LanguageError } from './chunk-LI2D53SH.js';
-import { __name, SupportedFormats, ReservedKeyword, __export, UNINTERPRETED_KEYWORDS } from './chunk-YD3MIYOO.js';
+import { DictionarySymbol, serializeInterpreterResult, stringifyInterpreterResult, isSome, LexerError, isSpace, isNumber2, isAlpha, isAlphaNumeric, ParserError, isLanguageError, NullSymbol, isTokenscriptSymbol, StringSymbol, NumberWithUnitSymbol, NumberSymbol, InterpreterError, BooleanSymbol, isNull, jsValueToSymbolType, ListSymbol, ColorSymbol, parseHexWithAlpha, basicSymbolTypes, typeName, typeEquals, ProcessorError, isObject, TokenSymbol, isArray, isString, getKeyAlt, isNumber, isBoolean, safeParseInt, serializeError, ensureValidAlpha, formatHex8, isTransparent, getResultTypeName, LanguageError } from './chunk-LSTH2XJ4.js';
+import { __name, SupportedFormats, ReservedKeyword, __export, UNINTERPRETED_KEYWORDS } from './chunk-ODVWXGOM.js';
 import { z, Color, Fn, Token, Unit, Constants, ZodError } from '@tokens-studio/schema-validation';
 
 // src/interpreter/tolerant/partial-nodes.ts
@@ -105,6 +105,15 @@ var _StringNode = class _StringNode {
 };
 __name(_StringNode, "StringNode");
 var StringNode = _StringNode;
+var _TemplateStringNode = class _TemplateStringNode {
+  constructor(parts, token) {
+    this.parts = parts;
+    this.token = token;
+    this.nodeType = "TemplateStringNode";
+  }
+};
+__name(_TemplateStringNode, "TemplateStringNode");
+var TemplateStringNode = _TemplateStringNode;
 var _UnaryOpNode = class _UnaryOpNode {
   constructor(opToken, expr, token) {
     this.opToken = opToken;
@@ -402,6 +411,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) {
@@ -711,6 +724,51 @@ var _Lexer = class _Lexer {
       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 = "";
@@ -761,6 +819,9 @@ var _Lexer = class _Lexer {
       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());
       }
@@ -1687,6 +1748,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);
@@ -1746,6 +1810,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 = /* @__PURE__ */ __name(() => {
+      if (literal.length > 0) {
+        parts.push(new StringNode({ ...token, value: literal }));
+        literal = "";
+      }
+    }, "flushLiteral");
+    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 */);
@@ -2492,6 +2672,47 @@ var _Interpreter = class _Interpreter {
   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
@@ -3211,6 +3432,21 @@ var _DependencyGraph = class _DependencyGraph {
 __name(_DependencyGraph, "DependencyGraph");
 var DependencyGraph = _DependencyGraph;
 
+// src/processor/utils/name-validation.ts
+var INVALID_TOKEN_NAME_CHARS = /[ \t\n\r\f{}[\]]/;
+function validateTokenName(name) {
+  return name.length > 0 && !INVALID_TOKEN_NAME_CHARS.test(name);
+}
+__name(validateTokenName, "validateTokenName");
+function splitTokenPath(path) {
+  return path.split(".");
+}
+__name(splitTokenPath, "splitTokenPath");
+function validateTokenPath(path) {
+  return splitTokenPath(path).every(validateTokenName);
+}
+__name(validateTokenPath, "validateTokenPath");
+
 // src/processor/utils/structured-tokens.ts
 function matchesObjectParser(value, parsers) {
   if (!isObject(value)) return false;
@@ -3648,6 +3884,15 @@ var _PrefixResolver = class _PrefixResolver {
   parseAndBuildGraph() {
     this.earlyResolved = [];
     for (const [tokenName, tokenData] of this.tokens.entries()) {
+      if (!validateTokenPath(tokenName)) {
+        this.addIssue(tokenName, {
+          code: "INVALID_TOKEN_NAME",
+          severity: "error" /* ERROR */,
+          message: `token "${tokenName}" contains invalid characters in name (spaces, braces, or brackets are not allowed)`,
+          tokenName,
+          data: { path: tokenName }
+        });
+      }
       const tokenValue = getTokenValue(tokenData);
       if (isString(tokenValue) && UNINTERPRETED_KEYWORDS.includes(tokenValue)) {
         const symbol = new StringSymbol(tokenValue, this.config);
@@ -6999,6 +7244,6 @@ var ASTNodes = {
   UnaryOpNode
 };
 
-export { ASTNodes, ColorManager, ColorSpecificationSchema, Config, ConstantsSpecificationSchema, DEFAULT_LANGUAGE_OPTIONS, FunctionSpecificationSchema, FunctionsManager, IncompleteType, Interpreter, Lexer, ParseState, Parser, PartialBinOpNode, PartialFunctionCallNode, PartialParenNode, PartialReferenceNode, PartialStringNode, PartialUnaryOpNode, TokenResolver, UnitManager, UnitSpecificationSchema, ValidationSeverity, buildTokens, builders_exports, collectAllReferences, collectReferenceNodes, errorClasses, errorHelpers, evaluateExpression, fetchAndRegisterSchemas, fetchTokenScriptSchema, filterAST, flattenChildrenMap, flattenChildrenObject, getAffectedTokens, getBrokenReferences, getModifiedDependants, getRenamedReferences, hasPartialNodes, parseExpression, parseTolerantly, processTokenSets, processTokens, renameReferences, tokenizeTolerantly, walkAST };
-//# sourceMappingURL=chunk-UYVHWJIC.js.map
-//# sourceMappingURL=chunk-UYVHWJIC.js.map
+export { ASTNodes, ColorManager, ColorSpecificationSchema, Config, ConstantsSpecificationSchema, DEFAULT_LANGUAGE_OPTIONS, FunctionSpecificationSchema, FunctionsManager, IncompleteType, Interpreter, Lexer, ParseState, Parser, PartialBinOpNode, PartialFunctionCallNode, PartialParenNode, PartialReferenceNode, PartialStringNode, PartialUnaryOpNode, TokenResolver, UnitManager, UnitSpecificationSchema, ValidationSeverity, buildTokens, builders_exports, collectAllReferences, collectReferenceNodes, errorClasses, errorHelpers, evaluateExpression, fetchAndRegisterSchemas, fetchTokenScriptSchema, filterAST, flattenChildrenMap, flattenChildrenObject, getAffectedTokens, getBrokenReferences, getModifiedDependants, getRenamedReferences, hasPartialNodes, parseExpression, parseTolerantly, processTokenSets, processTokens, renameReferences, tokenizeTolerantly, validateTokenName, validateTokenPath, walkAST };
+//# sourceMappingURL=chunk-RWXDOZAS.js.map
+//# sourceMappingURL=chunk-RWXDOZAS.js.map