pulse-js-framework 1.7.32 → 1.7.37

package/cli/release.js

@@ -532,6 +532,92 @@ function verifyTagOnRemote(version) {
   }
 }
 
+/**
+ * Check if gh CLI is available
+ */
+function isGhCliAvailable() {
+  try {
+    execSync('gh --version', { cwd: root, stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create GitHub release using gh CLI
+ */
+function createGitHubRelease(version, title, changes) {
+  if (!isGhCliAvailable()) {
+    log.warn('  gh CLI not available, skipping GitHub release creation');
+    log.info('  Install gh CLI: https://cli.github.com/');
+    return { success: false, reason: 'gh-not-installed' };
+  }
+
+  // Build release notes
+  let notes = '';
+
+  if (title) {
+    notes += `## ${title}\n\n`;
+  }
+
+  if (changes.added?.length > 0) {
+    notes += `### ✨ Added\n\n`;
+    for (const item of changes.added) {
+      notes += `- ${item}\n`;
+    }
+    notes += '\n';
+  }
+
+  if (changes.changed?.length > 0) {
+    notes += `### 🔄 Changed\n\n`;
+    for (const item of changes.changed) {
+      notes += `- ${item}\n`;
+    }
+    notes += '\n';
+  }
+
+  if (changes.fixed?.length > 0) {
+    notes += `### 🐛 Fixed\n\n`;
+    for (const item of changes.fixed) {
+      notes += `- ${item}\n`;
+    }
+    notes += '\n';
+  }
+
+  if (changes.removed?.length > 0) {
+    notes += `### 🗑️ Removed\n\n`;
+    for (const item of changes.removed) {
+      notes += `- ${item}\n`;
+    }
+    notes += '\n';
+  }
+
+  // Write notes to temp file
+  const tempFile = join(tmpdir(), `pulse-release-notes-${Date.now()}.md`);
+  writeFileSync(tempFile, notes, 'utf-8');
+
+  try {
+    const releaseTitle = title ? `v${version} - ${title}` : `v${version}`;
+    const command = `gh release create v${version} --title "${releaseTitle}" --notes-file "${tempFile}"`;
+
+    log.info(`  Creating GitHub release v${version}...`);
+    execSync(command, { cwd: root, stdio: 'inherit' });
+
+    log.info(`  GitHub release created successfully`);
+    return { success: true };
+  } catch (error) {
+    log.error(`  Failed to create GitHub release: ${error.message}`);
+    return { success: false, error };
+  } finally {
+    try {
+      unlinkSync(tempFile);
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}
+
 /**
  * Execute a git command with error handling
  */
@@ -619,24 +705,53 @@ function gitCommitTagPush(newVersion, title, changes, dryRun = false) {
     return { success: false, stage: 'push', error: result.error };
   }
 
-  // git push --tags
-  result = execGitCommand('git push --tags', 'git push --tags');
-  if (!result.success) {
-    log.error('');
-    log.error('Tag push failed. The tag exists locally but not on remote.');
-    log.error('You can manually push tags with:');
-    log.error('  git push --tags');
-    return { success: false, stage: 'push-tags', error: result.error };
-  }
-
-  // Verify tag was pushed to remote
-  if (!verifyTagOnRemote(newVersion)) {
-    log.warn('');
-    log.warn('Tag push appeared to succeed but tag not found on remote.');
-    log.warn('You may need to manually verify or push with:');
-    log.warn('  git push --tags');
+  // git push --tags (use gh CLI if available for better error handling)
+  if (isGhCliAvailable()) {
+    // Use git push directly as gh doesn't have a push command
+    result = execGitCommand('git push --tags', 'git push --tags');
+    if (!result.success) {
+      log.error('');
+      log.error('Tag push failed. The tag exists locally but not on remote.');
+      log.error('You can manually push tags with:');
+      log.error('  git push --tags');
+      return { success: false, stage: 'push-tags', error: result.error };
+    }
+
+    // Verify tag was pushed using gh
+    try {
+      execSync(`gh release view v${newVersion}`, { cwd: root, stdio: 'ignore' });
+      log.info(`  Verified: tag v${newVersion} exists on remote (via gh)`);
+    } catch {
+      // Tag pushed but no release yet, which is fine
+      if (verifyTagOnRemote(newVersion)) {
+        log.info(`  Verified: tag v${newVersion} exists on remote`);
+      } else {
+        log.warn('');
+        log.warn('Tag push appeared to succeed but tag not found on remote.');
+        log.warn('You may need to manually verify or push with:');
+        log.warn('  git push --tags');
+      }
+    }
   } else {
-    log.info(`  Verified: tag v${newVersion} exists on remote`);
+    // Fallback to standard git push --tags
+    result = execGitCommand('git push --tags', 'git push --tags');
+    if (!result.success) {
+      log.error('');
+      log.error('Tag push failed. The tag exists locally but not on remote.');
+      log.error('You can manually push tags with:');
+      log.error('  git push --tags');
+      return { success: false, stage: 'push-tags', error: result.error };
+    }
+
+    // Verify tag was pushed to remote
+    if (!verifyTagOnRemote(newVersion)) {
+      log.warn('');
+      log.warn('Tag push appeared to succeed but tag not found on remote.');
+      log.warn('You may need to manually verify or push with:');
+      log.warn('  git push --tags');
+    } else {
+      log.info(`  Verified: tag v${newVersion} exists on remote`);
+    }
   }
 
   return { success: true };
@@ -714,6 +829,7 @@ Types:
 Options:
   --dry-run         Show what would be done without making changes
   --no-push         Create commit and tag but don't push
+  --no-gh-release   Skip creating GitHub release (only create tag)
   --title <text>    Release title (e.g., "Performance Improvements")
   --skip-prompt     Use empty changelog (for automated releases)
   --skip-docs-test  Skip documentation validation before release
@@ -733,6 +849,7 @@ Examples:
   pulse release patch --title "Security" --fixed "XSS vulnerability,SQL injection" -y
   pulse release patch --title "New API" --added "Feature A,Feature B" --fixed "Bug X" -y
   pulse release patch --discord-webhook "https://discord.com/api/webhooks/..."
+  pulse release patch --no-gh-release  # Create tag but skip GitHub release
   `);
 }
 
@@ -750,6 +867,7 @@ export async function runRelease(args) {
   // Parse options
   const dryRun = args.includes('--dry-run');
   const noPush = args.includes('--no-push');
+  const noGhRelease = args.includes('--no-gh-release');
   const skipPrompt = args.includes('--skip-prompt');
   const fromCommits = args.includes('--from-commits') || args.includes('--fc');
   const autoConfirm = args.includes('--yes') || args.includes('-y');
@@ -984,8 +1102,32 @@ export async function runRelease(args) {
   log.info(`Release v${newVersion} complete!`);
   log.info('');
 
+  // Create GitHub release using gh CLI
+  if (!dryRun && !noPush && !noGhRelease && hasChanges) {
+    log.info('Creating GitHub release...');
+    const ghResult = createGitHubRelease(newVersion, title, changes);
+
+    if (!ghResult.success) {
+      if (ghResult.reason === 'gh-not-installed') {
+        log.info('Manual step:');
+        log.info(`  Create GitHub release: https://github.com/vincenthirtz/pulse-js-framework/releases/new?tag=v${newVersion}`);
+      } else {
+        log.warn('GitHub release creation failed, but release was successful.');
+        log.info('Manual step:');
+        log.info(`  Create GitHub release: https://github.com/vincenthirtz/pulse-js-framework/releases/new?tag=v${newVersion}`);
+      }
+    }
+  } else if (dryRun) {
+    log.info('  [dry-run] Would create GitHub release using gh CLI');
+  } else if (noGhRelease) {
+    log.info('Skipping GitHub release creation (--no-gh-release)');
+    log.info('Manual step:');
+    log.info(`  Create GitHub release: https://github.com/vincenthirtz/pulse-js-framework/releases/new?tag=v${newVersion}`);
+  }
+
   // Send Discord notification if webhook URL provided
   if (discordWebhook && !dryRun) {
+    log.info('');
     log.info('Sending Discord notification...');
     try {
       await sendDiscordNotification(discordWebhook, newVersion, title, changes);
@@ -996,9 +1138,4 @@ export async function runRelease(args) {
   } else if (discordWebhook && dryRun) {
     log.info('  [dry-run] Would send Discord notification to webhook');
   }
-
-  if (!dryRun && !noPush) {
-    log.info('Next step:');
-    log.info(`  Create GitHub release: https://github.com/vincenthirtz/pulse-js-framework/releases/new?tag=v${newVersion}`);
-  }
 }

package/compiler/parser.js

@@ -100,7 +100,9 @@ export class Parser {
    * Peek at token at offset
    */
   peek(offset = 1) {
-    return this.tokens[this.pos + offset];
+    const index = this.pos + offset;
+    if (index < 0 || index >= this.tokens.length) return undefined;
+    return this.tokens[index];
   }
 
   /**
@@ -1118,15 +1120,31 @@ export class Parser {
   }
 
   /**
-   * Parse assignment expression (a = b)
+   * Parse assignment expression (a = b, a += b, a -= b, etc.)
    */
   parseAssignmentExpression() {
     const left = this.parseConditionalExpression();
 
-    if (this.is(TokenType.EQ)) {
-      this.advance();
+    // Check for assignment operators
+    const assignmentOps = [
+      TokenType.EQ,           // =
+      TokenType.PLUS_ASSIGN,  // +=
+      TokenType.MINUS_ASSIGN, // -=
+      TokenType.STAR_ASSIGN,  // *=
+      TokenType.SLASH_ASSIGN, // /=
+      TokenType.AND_ASSIGN,   // &&=
+      TokenType.OR_ASSIGN,    // ||=
+      TokenType.NULLISH_ASSIGN // ??=
+    ];
+
+    if (this.isAny(...assignmentOps)) {
+      const operator = this.advance().value;
       const right = this.parseAssignmentExpression();
-      return new ASTNode(NodeType.AssignmentExpression, { left, right });
+      return new ASTNode(NodeType.AssignmentExpression, {
+        left,
+        right,
+        operator
+      });
     }
 
     return left;
@@ -1545,15 +1563,83 @@ export class Parser {
    */
   parseStyleBlock() {
     this.expect(TokenType.STYLE);
-    this.expect(TokenType.LBRACE);
+    const startBrace = this.expect(TokenType.LBRACE);
 
-    const rules = [];
-    while (!this.is(TokenType.RBRACE) && !this.is(TokenType.EOF)) {
-      rules.push(this.parseStyleRule());
+    // Extract raw CSS content for preprocessor support
+    // Instead of parsing token by token, collect all tokens until matching }
+    const rawTokens = [];
+    let braceDepth = 1; // We've already consumed the opening {
+    const startPos = this.pos;
+
+    while (braceDepth > 0 && !this.is(TokenType.EOF)) {
+      const token = this.current();
+      if (token.type === TokenType.LBRACE) braceDepth++;
+      if (token.type === TokenType.RBRACE) braceDepth--;
+
+      if (braceDepth > 0) {
+        rawTokens.push(token);
+        this.advance();
+      }
     }
 
     this.expect(TokenType.RBRACE);
-    return new ASTNode(NodeType.StyleBlock, { rules });
+
+    // Reconstruct raw CSS from tokens for preprocessor
+    const rawCSS = this.reconstructCSS(rawTokens);
+
+    // Try to parse as structured CSS (will work for plain CSS)
+    // If parsing fails, fall back to raw mode for preprocessors
+    let rules = [];
+    let parseError = null;
+
+    // Reset to try parsing
+    const savedPos = this.pos;
+    this.pos = startPos;
+
+    try {
+      while (!this.is(TokenType.RBRACE) && !this.is(TokenType.EOF)) {
+        rules.push(this.parseStyleRule());
+      }
+    } catch (error) {
+      // Parsing failed - likely preprocessor syntax (LESS/SASS/Stylus)
+      parseError = error;
+      rules = []; // Clear any partial parse
+    }
+
+    // Restore position to after the closing }
+    this.pos = savedPos;
+
+    return new ASTNode(NodeType.StyleBlock, {
+      rules,
+      raw: rawCSS,
+      parseError: parseError ? parseError.message : null
+    });
+  }
+
+  /**
+   * Reconstruct CSS from tokens, preserving formatting
+   */
+  reconstructCSS(tokens) {
+    if (!tokens.length) return '';
+
+    const lines = [];
+    let currentLine = [];
+    let lastLine = tokens[0].line;
+
+    for (const token of tokens) {
+      if (token.line !== lastLine) {
+        lines.push(currentLine.join(''));
+        currentLine = [];
+        lastLine = token.line;
+      }
+      currentLine.push(token.raw || token.value);
+    }
+
+    if (currentLine.length > 0) {
+      lines.push(currentLine.join(''));
+    }
+
+    return lines.join('\n').trim();
   }
 
   /**

package/compiler/transformer/constants.js

@@ -5,7 +5,7 @@
  */
 
 /** Generate a unique scope ID for CSS scoping */
-export const generateScopeId = () => 'p' + Math.random().toString(36).substring(2, 8);
+export const generateScopeId = () => 'p' + Math.random().toString(36).substring(2, 12);
 
 /** Token types that should not have space after them */
 export const NO_SPACE_AFTER = new Set([

package/compiler/transformer/expressions.js

@@ -82,12 +82,12 @@ export function transformExpression(transformer, node) {
 
     case NodeType.UpdateExpression: {
       const argument = transformExpression(transformer, node.argument);
-      // For state variables, convert x++ to x.set(x.get() + 1)
+      // For state variables, convert x++ to x.update(x => x + 1)
       if (node.argument.type === NodeType.Identifier &&
           transformer.stateVars.has(node.argument.name)) {
         const name = node.argument.name;
-        const delta = node.operator === '++' ? 1 : -1;
-        return `${name}.set(${name}.get() + ${delta})`;
+        const op = node.operator === '++' ? '+' : '-';
+        return `${name}.update(_${name} => _${name} ${op} 1)`;
       }
       return node.prefix
         ? `${node.operator}${argument}`
@@ -117,12 +117,32 @@ export function transformExpression(transformer, node) {
     case NodeType.AssignmentExpression: {
       const left = transformExpression(transformer, node.left);
       const right = transformExpression(transformer, node.right);
-      // For state variables, convert to .set()
+      const operator = node.operator || '=';
+
+      // For state variables, convert to .set() or .update()
       if (node.left.type === NodeType.Identifier &&
           transformer.stateVars.has(node.left.name)) {
-        return `${node.left.name}.set(${right})`;
+        const varName = node.left.name;
+
+        // Compound assignment operators (+=, -=, *=, /=, &&=, ||=, ??=)
+        if (operator !== '=') {
+          // Convert compound assignment to update
+          // a += b  =>  a.update(_a => _a + b)
+          // a -= b  =>  a.update(_a => _a - b)
+          const baseOp = operator.slice(0, -1); // Remove trailing '='
+          return `${varName}.update(_${varName} => _${varName} ${baseOp} ${right})`;
+        }
+
+        // Simple assignment: a = b  =>  a.set(b)
+        return `${varName}.set(${right})`;
+      }
+
+      // Regular assignment (non-state vars)
+      if (operator === '=') {
+        return `(${left} = ${right})`;
       }
-      return `(${left} = ${right})`;
+      // Compound assignment for non-state vars
+      return `(${left} ${operator} ${right})`;
     }
 
     case NodeType.ArrayLiteral: {
@@ -162,14 +182,54 @@ export function transformExpression(transformer, node) {
  * @returns {string} Transformed expression string
  */
 export function transformExpressionString(transformer, exprStr) {
-  // Simple transformation: wrap state and prop vars with .get()
+  // Transform state and prop vars in expression strings (interpolations, attribute bindings)
   // Both are now reactive (useProp returns computed for uniform interface)
   let result = exprStr;
 
-  // Transform state vars
+  // First, handle assignments to state vars: stateVar = expr -> stateVar.set(expr)
+  // This must happen before the generic .get() replacement to avoid generating
+  // invalid code like stateVar.get() = expr (LHS of assignment is not a reference)
+  for (const stateVar of transformer.stateVars) {
+    // Compound assignment: stateVar += expr -> stateVar.update(_v => _v + expr)
+    result = result.replace(
+      new RegExp(`\\b${stateVar}\\s*(\\+=|-=|\\*=|\\/=|&&=|\\|\\|=|\\?\\?=)\\s*`, 'g'),
+      (_match, op) => {
+        const baseOp = op.slice(0, -1); // Remove trailing '='
+        return `${stateVar}.update(_v => _v ${baseOp} `;
+      }
+    );
+    // Close the .update() call - find the end of the expression after the replacement
+    // This is handled by the fact that the expression continues after the replacement text
+    // and the closing paren is added by wrapping logic below.
+
+    // Simple assignment: stateVar = expr -> stateVar.set(expr)
+    // Use negative lookbehind to skip compound assignments (already handled)
+    // Use negative lookahead to skip == and ===
+    result = result.replace(
+      new RegExp(`\\b${stateVar}\\s*=(?!=)`, 'g'),
+      `${stateVar}.set(`
+    );
+  }
+
+  // If we inserted .set( or .update(, we need to close the parenthesis
+  // Find unclosed .set( and .update( calls and close them at end of expression
+  if (result.includes('.set(') || result.includes('.update(_v =>')) {
+    // For .update(_v => _v op expr), close with )
+    result = result.replace(
+      /\.update\(_v => _v [^\)]*$/,
+      (m) => m + ')'
+    );
+    // For .set(expr), close with )
+    result = result.replace(
+      /\.set\(([^)]*$)/,
+      (_m, expr) => `.set(${expr})`
+    );
+  }
+
+  // Transform state var reads (not already transformed to .get/.set/.update)
   for (const stateVar of transformer.stateVars) {
     result = result.replace(
-      new RegExp(`\\b${stateVar}\\b`, 'g'),
+      new RegExp(`\\b${stateVar}\\b(?!\\.(?:get|set|update))`, 'g'),
       `${stateVar}.get()`
     );
   }