vsn 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -513,10 +513,12 @@ var ProgramNode = class extends BaseNode {
   }
 };
 var UseNode = class extends BaseNode {
-  constructor(name, alias) {
+  constructor(name, alias, flags = {}, flagArgs = {}) {
     super("Use");
     this.name = name;
     this.alias = alias;
+    this.flags = flags;
+    this.flagArgs = flagArgs;
   }
 };
 var BlockNode = class extends BaseNode {
@@ -572,24 +574,117 @@ var OnBlockNode = class extends BaseNode {
   }
 };
 var AssignmentNode = class extends BaseNode {
-  constructor(target, value) {
+  constructor(target, value, operator = "=") {
     super("Assignment");
     this.target = target;
     this.value = value;
+    this.operator = operator;
   }
   async evaluate(context) {
     if (!context.scope || !context.scope.setPath) {
       return void 0;
     }
     const value = await this.value.evaluate(context);
+    if (this.operator !== "=") {
+      return await this.applyCompoundAssignment(context, value);
+    }
     if (this.target instanceof IdentifierExpression && this.target.name.startsWith("root.") && context.rootScope) {
       const path = this.target.name.slice("root.".length);
-      context.rootScope.setPath?.(`self.${path}`, value);
+      context.rootScope.setPath?.(path, value);
       return value;
     }
+    if (this.target instanceof MemberExpression || this.target instanceof IndexExpression) {
+      const resolved = await this.resolveAssignmentTarget(context);
+      if (resolved?.scope?.setPath) {
+        resolved.scope.setPath(resolved.path, value);
+        return value;
+      }
+    }
     this.assignTarget(context, this.target, value);
     return value;
   }
+  async applyCompoundAssignment(context, value) {
+    if (!context.scope || !context.scope.setPath) {
+      return void 0;
+    }
+    const resolved = await this.resolveAssignmentTarget(context);
+    if (!resolved) {
+      throw new Error("Compound assignment requires a simple identifier or member path");
+    }
+    const { scope, path } = resolved;
+    const current = scope?.getPath ? scope.getPath(path) : void 0;
+    let result;
+    if (this.operator === "+=") {
+      result = current + value;
+    } else if (this.operator === "-=") {
+      result = current - value;
+    } else if (this.operator === "*=") {
+      result = current * value;
+    } else {
+      result = current / value;
+    }
+    scope?.setPath?.(path, result);
+    return result;
+  }
+  async resolveAssignmentTarget(context) {
+    if (this.target instanceof IdentifierExpression) {
+      const isRoot = this.target.name.startsWith("root.");
+      const rawPath = isRoot ? this.target.name.slice("root.".length) : this.target.name;
+      if (isRoot) {
+        return { scope: context.scope, path: `root.${rawPath}` };
+      }
+      return { scope: context.scope, path: rawPath };
+    }
+    if (this.target instanceof MemberExpression) {
+      const resolvedPath = this.target.getIdentifierPath();
+      if (!resolvedPath) {
+        return null;
+      }
+      const path = resolvedPath.path;
+      const isRoot = path.startsWith("root.");
+      const rawPath = isRoot ? path.slice("root.".length) : path;
+      if (isRoot) {
+        return { scope: context.scope, path: `root.${rawPath}` };
+      }
+      return { scope: context.scope, path: rawPath };
+    }
+    if (this.target instanceof IndexExpression) {
+      const path = await this.resolveIndexPath(context, this.target);
+      if (!path) {
+        return null;
+      }
+      const isRoot = path.startsWith("root.");
+      const rawPath = isRoot ? path.slice("root.".length) : path;
+      if (isRoot) {
+        return { scope: context.scope, path: `root.${rawPath}` };
+      }
+      return { scope: context.scope, path: rawPath };
+    }
+    return null;
+  }
+  async resolveIndexPath(context, expr) {
+    const base = await this.resolveTargetPath(context, expr.target);
+    if (!base) {
+      return null;
+    }
+    const indexValue = await expr.index.evaluate(context);
+    if (indexValue == null) {
+      return null;
+    }
+    return `${base}.${indexValue}`;
+  }
+  async resolveTargetPath(context, target) {
+    if (target instanceof IdentifierExpression) {
+      return target.name;
+    }
+    if (target instanceof MemberExpression) {
+      return target.getIdentifierPath()?.path ?? null;
+    }
+    if (target instanceof IndexExpression) {
+      return this.resolveIndexPath(context, target);
+    }
+    return null;
+  }
   assignTarget(context, target, value) {
     if (!context.scope || !context.scope.setPath) {
       return;
@@ -1460,11 +1555,46 @@ var Parser = class _Parser {
         this.stream.skipWhitespace();
         alias = this.stream.expect("Identifier" /* Identifier */).value;
       }
+      const { flags, flagArgs } = this.parseUseFlags();
       this.stream.skipWhitespace();
       this.stream.expect("Semicolon" /* Semicolon */);
-      return new UseNode(name, alias);
+      return new UseNode(name, alias, flags, flagArgs);
     });
   }
+  parseUseFlags() {
+    const flags = {};
+    const flagArgs = {};
+    while (true) {
+      this.stream.skipWhitespace();
+      if (this.stream.peek()?.type !== "Bang" /* Bang */) {
+        break;
+      }
+      this.stream.next();
+      const name = this.stream.expect("Identifier" /* Identifier */).value;
+      if (name !== "wait") {
+        throw new Error(`Unknown flag ${name}`);
+      }
+      flags.wait = true;
+      if (this.stream.peek()?.type === "LParen" /* LParen */) {
+        this.stream.next();
+        this.stream.skipWhitespace();
+        const timeoutToken = this.stream.expect("Number" /* Number */);
+        const timeoutMs = Number(timeoutToken.value);
+        let intervalMs;
+        this.stream.skipWhitespace();
+        if (this.stream.peek()?.type === "Comma" /* Comma */) {
+          this.stream.next();
+          this.stream.skipWhitespace();
+          const intervalToken = this.stream.expect("Number" /* Number */);
+          intervalMs = Number(intervalToken.value);
+          this.stream.skipWhitespace();
+        }
+        this.stream.expect("RParen" /* RParen */);
+        flagArgs.wait = { timeoutMs, ...intervalMs !== void 0 ? { intervalMs } : {} };
+      }
+    }
+    return { flags, flagArgs };
+  }
   wrapErrors(fn) {
     try {
       return fn();
@@ -1695,11 +1825,11 @@ ${caret}`;
   parseAssignment() {
     const target = this.parseAssignmentTarget();
     this.stream.skipWhitespace();
-    this.stream.expect("Equals" /* Equals */);
+    const operator = this.parseAssignmentOperator();
     this.stream.skipWhitespace();
     const value = this.parseExpression();
     this.consumeStatementTerminator();
-    return new AssignmentNode(target, value);
+    return new AssignmentNode(target, value, operator);
   }
   parseExpression() {
     return this.parsePipeExpression();
@@ -2281,7 +2411,14 @@ ${caret}`;
       return this.parseObjectPattern();
     }
     if (token.type === "Identifier" /* Identifier */) {
-      return new IdentifierExpression(this.parseIdentifierPath());
+      const expr = this.parseCallExpression();
+      if (expr instanceof CallExpression) {
+        throw new Error("Invalid assignment target CallExpression");
+      }
+      if (expr instanceof IdentifierExpression || expr instanceof MemberExpression || expr instanceof IndexExpression) {
+        return expr;
+      }
+      throw new Error("Invalid assignment target");
     }
     throw new Error(`Invalid assignment target ${token.type}`);
   }
@@ -2560,12 +2697,31 @@ ${caret}`;
       while (this.stream.peekNonWhitespace(index)?.type === "Dot" /* Dot */ && this.stream.peekNonWhitespace(index + 1)?.type === "Identifier" /* Identifier */) {
         index += 2;
       }
-      return this.stream.peekNonWhitespace(index)?.type === "Equals" /* Equals */;
+      while (this.stream.peekNonWhitespace(index)?.type === "LBracket" /* LBracket */) {
+        let depth = 0;
+        while (true) {
+          const token = this.stream.peekNonWhitespace(index);
+          if (!token) {
+            return false;
+          }
+          if (token.type === "LBracket" /* LBracket */) {
+            depth += 1;
+          } else if (token.type === "RBracket" /* RBracket */) {
+            depth -= 1;
+            if (depth === 0) {
+              index += 1;
+              break;
+            }
+          }
+          index += 1;
+        }
+      }
+      return this.isAssignmentOperatorStart(index);
     }
     if (first.type === "At" /* At */ || first.type === "Dollar" /* Dollar */) {
       const second = this.stream.peekNonWhitespace(1);
       const third = this.stream.peekNonWhitespace(2);
-      return second?.type === "Identifier" /* Identifier */ && third?.type === "Equals" /* Equals */;
+      return second?.type === "Identifier" /* Identifier */ && this.isAssignmentOperatorStart(2);
     }
     if (first.type === "LBrace" /* LBrace */ || first.type === "LBracket" /* LBracket */) {
       const stack = [];
@@ -2580,7 +2736,7 @@ ${caret}`;
         } else if (token.type === "RBrace" /* RBrace */ || token.type === "RBracket" /* RBracket */) {
           stack.pop();
           if (stack.length === 0) {
-            return this.stream.peekNonWhitespace(index + 1)?.type === "Equals" /* Equals */;
+            return this.isAssignmentOperatorStart(index + 1);
           }
         }
         index += 1;
@@ -2588,6 +2744,20 @@ ${caret}`;
     }
     return false;
   }
+  isAssignmentOperatorStart(index) {
+    const token = this.stream.peekNonWhitespace(index);
+    if (!token) {
+      return false;
+    }
+    if (token.type === "Equals" /* Equals */) {
+      return true;
+    }
+    if (token.type === "Plus" /* Plus */ || token.type === "Minus" /* Minus */ || token.type === "Star" /* Star */ || token.type === "Slash" /* Slash */) {
+      const next = this.stream.peekNonWhitespace(index + 1);
+      return next?.type === "Equals" /* Equals */;
+    }
+    return false;
+  }
   isCallStart() {
     const first = this.stream.peekNonWhitespace(0);
     if (!first || first.type !== "Identifier" /* Identifier */) {
@@ -2812,10 +2982,35 @@ ${caret}`;
   parseAssignmentExpression() {
     const target = this.parseAssignmentTarget();
     this.stream.skipWhitespace();
-    this.stream.expect("Equals" /* Equals */);
+    const operator = this.parseAssignmentOperator();
     this.stream.skipWhitespace();
     const value = this.parseExpression();
-    return new AssignmentNode(target, value);
+    return new AssignmentNode(target, value, operator);
+  }
+  parseAssignmentOperator() {
+    const next = this.stream.peek();
+    if (!next) {
+      throw new Error("Expected assignment operator");
+    }
+    if (next.type === "Equals" /* Equals */) {
+      this.stream.next();
+      return "=";
+    }
+    if (next.type === "Plus" /* Plus */ || next.type === "Minus" /* Minus */ || next.type === "Star" /* Star */ || next.type === "Slash" /* Slash */) {
+      const op = this.stream.next();
+      this.stream.expect("Equals" /* Equals */);
+      if (op.type === "Plus" /* Plus */) {
+        return "+=";
+      }
+      if (op.type === "Minus" /* Minus */) {
+        return "-=";
+      }
+      if (op.type === "Star" /* Star */) {
+        return "*=";
+      }
+      return "/=";
+    }
+    throw new Error("Expected assignment operator");
   }
   parseTryBlock() {
     this.stream.expect("Try" /* Try */);
@@ -3318,6 +3513,7 @@ var Engine = class _Engine {
   ignoredAdded = /* @__PURE__ */ new WeakMap();
   diagnostics;
   logger;
+  pendingUses = [];
   constructor(options = {}) {
     this.diagnostics = options.diagnostics ?? false;
     this.logger = options.logger ?? console;
@@ -3387,6 +3583,10 @@ var Engine = class _Engine {
   registerBehaviors(source) {
     const program = new Parser(source, { customFlags: new Set(this.flagHandlers.keys()) }).parseProgram();
     for (const use of program.uses) {
+      if (use.flags?.wait) {
+        this.pendingUses.push(this.waitForUseGlobal(use));
+        continue;
+      }
       const value = this.resolveGlobalPath(use.name);
       if (value === void 0) {
         console.warn(`vsn: global '${use.name}' not found`);
@@ -3436,6 +3636,52 @@ var Engine = class _Engine {
     }
     return value;
   }
+  async waitForUses() {
+    while (this.pendingUses.length > 0) {
+      const pending = this.pendingUses;
+      this.pendingUses = [];
+      await Promise.all(pending);
+    }
+  }
+  waitForUseGlobal(use) {
+    const config = use.flagArgs?.wait ?? {};
+    const timeoutMs = config.timeoutMs ?? 1e4;
+    const initialDelayMs = config.intervalMs ?? 100;
+    const maxDelayMs = 1e3;
+    const existing = this.resolveGlobalPath(use.name);
+    if (existing !== void 0) {
+      this.registerGlobal(use.alias, existing);
+      return Promise.resolve();
+    }
+    if (timeoutMs <= 0) {
+      this.emitUseError(use.name, new Error(`vsn: global '${use.name}' not found`));
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      let elapsedMs = 0;
+      let delayMs = initialDelayMs;
+      const check = () => {
+        const value = this.resolveGlobalPath(use.name);
+        if (value !== void 0) {
+          this.registerGlobal(use.alias, value);
+          resolve();
+          return;
+        }
+        if (elapsedMs >= timeoutMs) {
+          this.emitUseError(use.name, new Error(`vsn: global '${use.name}' not found`));
+          resolve();
+          return;
+        }
+        const scheduledDelay = Math.min(delayMs, timeoutMs - elapsedMs);
+        setTimeout(() => {
+          elapsedMs += scheduledDelay;
+          delayMs = Math.min(delayMs * 2, maxDelayMs);
+          check();
+        }, scheduledDelay);
+      };
+      check();
+    });
+  }
   getScope(element, parentScope) {
     const existing = this.scopes.get(element);
     if (existing) {
@@ -3559,6 +3805,7 @@ var Engine = class _Engine {
     }
   }
   async applyBehaviors(root) {
+    await this.waitForUses();
     if (this.behaviorRegistry.length === 0) {
       return;
     }
@@ -3966,6 +4213,19 @@ var Engine = class _Engine {
       })
     );
   }
+  emitUseError(name, error) {
+    const selector = `use:${name}`;
+    this.logger.warn?.("vsn:error", { error, selector });
+    const target = globalThis.document;
+    if (target && typeof target.dispatchEvent === "function") {
+      target.dispatchEvent(
+        new CustomEvent("vsn:error", {
+          detail: { error, selector },
+          bubbles: true
+        })
+      );
+    }
+  }
   attachOnHandler(element, config) {
     const options = this.getListenerOptions(config.modifiers);
     const listenerTarget = config.modifiers?.includes("outside") ? element.ownerDocument : element;