@xaendar/vscode-client 0.9.28 → 0.9.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xaendar/vscode-client",
-  "version": "0.9.28",
+  "version": "0.9.30",
   "description": "",
   "author": "Kaitenjo",
   "license": "MIT",

package/server/server.cjs

@@ -228053,6 +228053,17 @@ var CompilerContext = class _CompilerContext {
   hasUnresolvableIdentifier(name) {
     return this._unresolvableIdentifiers.has(name) || (this.parent?.hasUnresolvableIdentifier(name) ?? false);
   }
+  /**
+   * Resolves the kind (`'value'` or `'signal'`) of a unresolvable declared identifier,
+   * walking up the scope chain if not found in this scope.
+   *
+   * @param name - The unresolvable identifier name to look up.
+   * @returns The unresolvable identifier's kind, or `undefined` if it isn't declared
+   *   anywhere in the scope chain.
+   */
+  getUnresolvableIdentifierKind(name) {
+    return this._unresolvableIdentifiers.get(name) ?? this.parent?.getUnresolvableIdentifierKind(name);
+  }
 };
 
 // ../packages/compiler/src/generator/utils/generator.utils.ts
@@ -228260,8 +228271,8 @@ function resolveExpression(expression, compilerContext, options) {
 function emitNode(node, parent, compilerContext, options) {
   if ((0, import_typescript3.isIdentifier)(node) && needsResolution(node, parent)) {
     const text = node.text;
-    if (compilerContext.hasUnresolvableIdentifier(text)) {
-      return { expression: text };
+    if (compilerContext.hasUnresolvableIdentifier(text) || options.skipResolution) {
+      return { expression: text, reactive: compilerContext.getUnresolvableIdentifierKind(text) === "signal" };
     }
     const resolvedValue = resolveIdentifierAccess(text, compilerContext);
     if (resolvedValue) {
@@ -228324,7 +228335,7 @@ function getIdentifier(prefix, parentNode, index) {
 function mapDefaultOptions(options) {
   return {
     resolver: options?.resolver ?? "this",
-    emitReactive: options?.emitReactive ?? false
+    skipResolution: options?.skipResolution ?? false
   };
 }
 
@@ -228383,10 +228394,10 @@ function generateElement(node, parentNode, index, compilerContext, anchor) {
 function mapAttributes(attributes, compilerContext) {
   return attributes?.map(({ name, value }) => {
     if (typeof value === "string") {
-      return `{ name: '${name}', value: () => '${value}', reactive: false },`;
+      return `{ name: '${name}', value: () => '${value}', setter: bindAttribute },`;
     } else {
       const { expression, reactive } = resolveExpression(value.expression, compilerContext);
-      return `{ name: '${name}', value: () => ${expression}, reactive: ${reactive} },`;
+      return `{ name: '${name}', value: () => ${expression},  setter: ${reactive ? "bindReactiveAttribute" : "bindAttribute"} },`;
     }
   });
 }
@@ -228455,7 +228466,7 @@ function generateFor(node, parentNode, index, compilerContext) {
   const evenName = resolveImplicit(node, "$even");
   const oddName = resolveImplicit(node, "$odd");
   const forContext = new CompilerContext(compilerContext);
-  forContext.addUnresolvableIdentifier(node.itemAlias);
+  forContext.addIdentifier(node.itemAlias);
   const identifiers = [indexName, firstName, lastName, evenName, oddName];
   for (let i2 = 0; i2 < identifiers.length; i2++) {
     forContext.addUnresolvableIdentifier(identifiers[i2], "signal");
@@ -228479,7 +228490,7 @@ function generateFor(node, parentNode, index, compilerContext) {
     },
     args: [forKey, "parentContext", itemsName, counterName, "anchor"]
   });
-  retVal.code.push(`_for(${parentNode}, context, () => ${iterableExpr}, ${node.itemAlias} => ${resolveExpression(node.trackExpression, forContext).expression}, this.${forKey}.bind(this));`);
+  retVal.code.push(`_for(${parentNode}, context, () => ${iterableExpr}, (${node.itemAlias}, ${indexName}) => ${resolveExpression(node.trackExpression, forContext, { skipResolution: true }).expression}, this.${forKey}.bind(this));`);
   return retVal;
 }
 function resolveImplicit(node, implicit) {
@@ -228617,7 +228628,10 @@ var Generator = class {
     };
     try {
       this._nodeToProcess.clear();
-      const compilerContext = new CompilerContext(signals.map((signal) => [signal, "signal"]));
+      const compilerContext = new CompilerContext();
+      for (let i2 = 0; i2 < signals.length; i2++) {
+        compilerContext.addUnresolvableIdentifier(signals[i2], "signal");
+      }
       const generatedCode = [
         "_render() {",
         ...indent([