pulse-js-framework 1.4.3 → 1.4.4

package/README.md

@@ -14,6 +14,7 @@ A declarative DOM framework with CSS selector-based structure and reactive pulsa
 - **Lightweight** - Minimal footprint, maximum performance
 - **Router & Store** - Built-in SPA routing and state management
 - **Mobile Apps** - Build native Android & iOS apps (zero dependencies)
+- **TypeScript Support** - Full type definitions for IDE autocomplete
 
 ## Installation
 
@@ -398,6 +399,27 @@ onNativeReady(({ platform }) => {
 
 **Available APIs:** Storage, Device Info, Network Status, Toast, Vibration, Clipboard, App Lifecycle
 
+## TypeScript Support
+
+Pulse includes full TypeScript definitions for IDE autocomplete and type checking:
+
+```typescript
+import { pulse, effect, computed, Pulse } from 'pulse-js-framework/runtime';
+import { el, list, when } from 'pulse-js-framework/runtime';
+import { createRouter, Router } from 'pulse-js-framework/runtime/router';
+import { createStore, Store } from 'pulse-js-framework/runtime/store';
+
+// Full autocomplete for all APIs
+const count: Pulse<number> = pulse(0);
+const doubled = computed(() => count.get() * 2);
+
+effect(() => {
+  console.log(count.get()); // Type-safe access
+});
+```
+
+Types are automatically detected by IDEs (VS Code, WebStorm) without additional configuration.
+
 ## Examples
 
 - [Blog](examples/blog) - Full blog app with CRUD, categories, search, dark mode

package/cli/mobile.js

@@ -4,7 +4,7 @@
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync, readdirSync } from 'fs';
-import { join, resolve, dirname } from 'path';
+import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
 
@@ -14,6 +14,38 @@ const __dirname = dirname(__filename);
 const MOBILE_DIR = 'mobile';
 const CONFIG_FILE = 'pulse.mobile.json';
 
+// ============================================================================
+// Helper functions
+// ============================================================================
+
+/** Create directory if it doesn't exist */
+const mkdirp = (path) => !existsSync(path) && mkdirSync(path, { recursive: true });
+
+/** Create multiple directories at once */
+const mkdirs = (base, dirs) => dirs.forEach(d => mkdirp(join(base, d)));
+
+/** Write file (auto-creates parent directories) */
+const writeFile = (path, content) => {
+  mkdirp(dirname(path));
+  writeFileSync(path, content.trim());
+};
+
+/** Apply template variables to content */
+const applyTemplate = (content, config) => content
+  .replace(/\{\{APP_NAME\}\}/g, config.name)
+  .replace(/\{\{DISPLAY_NAME\}\}/g, config.displayName)
+  .replace(/\{\{PACKAGE_ID\}\}/g, config.packageId)
+  .replace(/\{\{VERSION\}\}/g, config.version)
+  .replace(/\{\{MIN_SDK\}\}/g, String(config.android?.minSdkVersion || 24))
+  .replace(/\{\{TARGET_SDK\}\}/g, String(config.android?.targetSdkVersion || 34))
+  .replace(/\{\{COMPILE_SDK\}\}/g, String(config.android?.compileSdkVersion || 34))
+  .replace(/\{\{IOS_TARGET\}\}/g, config.ios?.deploymentTarget || '13.0');
+
+/** Convert string to PascalCase */
+const toPascalCase = (str) => str
+  .replace(/[-_](.)/g, (_, c) => c.toUpperCase())
+  .replace(/^(.)/, (_, c) => c.toUpperCase());
+
 /**
  * Handle mobile subcommands
  */
@@ -419,67 +451,35 @@ function loadConfig(root) {
   return JSON.parse(readFileSync(configPath, 'utf-8'));
 }
 
-/**
- * Copy and process template files
- */
+/** Copy and process template files */
 function copyAndProcessTemplate(src, dest, config) {
-  if (!existsSync(src)) {
-    return;
-  }
-
-  mkdirSync(dest, { recursive: true });
+  if (!existsSync(src)) return;
+  mkdirp(dest);
 
-  const files = readdirSync(src, { withFileTypes: true });
-
-  for (const file of files) {
+  for (const file of readdirSync(src, { withFileTypes: true })) {
     const srcPath = join(src, file.name);
     const destPath = join(dest, file.name);
 
     if (file.isDirectory()) {
       copyAndProcessTemplate(srcPath, destPath, config);
     } else {
-      let content = readFileSync(srcPath, 'utf-8');
-
-      // Replace template variables
-      content = content
-        .replace(/\{\{APP_NAME\}\}/g, config.name)
-        .replace(/\{\{DISPLAY_NAME\}\}/g, config.displayName)
-        .replace(/\{\{PACKAGE_ID\}\}/g, config.packageId)
-        .replace(/\{\{VERSION\}\}/g, config.version)
-        .replace(/\{\{MIN_SDK\}\}/g, String(config.android?.minSdkVersion || 24))
-        .replace(/\{\{TARGET_SDK\}\}/g, String(config.android?.targetSdkVersion || 34))
-        .replace(/\{\{COMPILE_SDK\}\}/g, String(config.android?.compileSdkVersion || 34))
-        .replace(/\{\{IOS_TARGET\}\}/g, config.ios?.deploymentTarget || '13.0');
-
-      writeFileSync(destPath, content);
+      writeFileSync(destPath, applyTemplate(readFileSync(srcPath, 'utf-8'), config));
     }
   }
 }
 
-/**
- * Create Android project from scratch
- */
+/** Create Android project from scratch */
 function createAndroidProject(androidDir, config) {
   const packagePath = config.packageId.replace(/\./g, '/');
 
   // Create directory structure
-  const dirs = [
+  mkdirs(androidDir, [
     'app/src/main/java/' + packagePath,
-    'app/src/main/res/layout',
-    'app/src/main/res/values',
-    'app/src/main/res/drawable',
-    'app/src/main/res/mipmap-hdpi',
-    'app/src/main/res/mipmap-mdpi',
-    'app/src/main/res/mipmap-xhdpi',
-    'app/src/main/res/mipmap-xxhdpi',
-    'app/src/main/res/mipmap-xxxhdpi',
-    'app/src/main/assets/www',
-    'gradle/wrapper'
-  ];
-
-  for (const dir of dirs) {
-    mkdirSync(join(androidDir, dir), { recursive: true });
-  }
+    'app/src/main/res/layout', 'app/src/main/res/values', 'app/src/main/res/drawable',
+    'app/src/main/res/mipmap-hdpi', 'app/src/main/res/mipmap-mdpi',
+    'app/src/main/res/mipmap-xhdpi', 'app/src/main/res/mipmap-xxhdpi', 'app/src/main/res/mipmap-xxxhdpi',
+    'app/src/main/assets/www', 'gradle/wrapper'
+  ]);
 
   // MainActivity.java
   writeFileSync(join(androidDir, 'app/src/main/java', packagePath, 'MainActivity.java'), `
@@ -906,21 +906,9 @@ gradle %*
 `.trim());
 }
 
-/**
- * Create iOS project from scratch
- */
+/** Create iOS project from scratch */
 function createIOSProject(iosDir, config) {
-  // Create directory structure
-  const dirs = [
-    'PulseApp',
-    'PulseApp/www',
-    'PulseApp/Assets.xcassets',
-    'PulseApp.xcodeproj'
-  ];
-
-  for (const dir of dirs) {
-    mkdirSync(join(iosDir, dir), { recursive: true });
-  }
+  mkdirs(iosDir, ['PulseApp', 'PulseApp/www', 'PulseApp/Assets.xcassets', 'PulseApp.xcodeproj']);
 
   // AppDelegate.swift
   writeFileSync(join(iosDir, 'PulseApp/AppDelegate.swift'), `
@@ -1430,18 +1418,7 @@ function generateXcodeProject(config) {
 `;
 }
 
-/**
- * Convert string to PascalCase
- */
-function toPascalCase(str) {
-  return str
-    .replace(/[-_](.)/g, (_, char) => char.toUpperCase())
-    .replace(/^(.)/, (_, char) => char.toUpperCase());
-}
-
-/**
- * Show mobile help
- */
+/** Show mobile help */
 function showMobileHelp() {
   console.log(`
 Pulse Mobile - Zero-Dependency Mobile Platform

package/compiler/parser.js

@@ -384,39 +384,36 @@ export class Parser {
     return new ASTNode(NodeType.Property, { name: name.value, value });
   }
 
+  /**
+   * Try to parse a literal token (STRING, NUMBER, TRUE, FALSE, NULL)
+   * Returns the AST node or null if not a literal
+   */
+  tryParseLiteral() {
+    const token = this.current();
+    if (!token) return null;
+
+    const literalMap = {
+      [TokenType.STRING]: () => new ASTNode(NodeType.Literal, { value: this.advance().value, raw: token.raw }),
+      [TokenType.NUMBER]: () => new ASTNode(NodeType.Literal, { value: this.advance().value }),
+      [TokenType.TRUE]: () => (this.advance(), new ASTNode(NodeType.Literal, { value: true })),
+      [TokenType.FALSE]: () => (this.advance(), new ASTNode(NodeType.Literal, { value: false })),
+      [TokenType.NULL]: () => (this.advance(), new ASTNode(NodeType.Literal, { value: null }))
+    };
+
+    return literalMap[token.type]?.() || null;
+  }
+
   /**
    * Parse a value (literal, object, array, etc.)
    */
   parseValue() {
-    if (this.is(TokenType.LBRACE)) {
-      return this.parseObjectLiteral();
-    }
-    if (this.is(TokenType.LBRACKET)) {
-      return this.parseArrayLiteral();
-    }
-    if (this.is(TokenType.STRING)) {
-      const token = this.advance();
-      return new ASTNode(NodeType.Literal, { value: token.value, raw: token.raw });
-    }
-    if (this.is(TokenType.NUMBER)) {
-      const token = this.advance();
-      return new ASTNode(NodeType.Literal, { value: token.value });
-    }
-    if (this.is(TokenType.TRUE)) {
-      this.advance();
-      return new ASTNode(NodeType.Literal, { value: true });
-    }
-    if (this.is(TokenType.FALSE)) {
-      this.advance();
-      return new ASTNode(NodeType.Literal, { value: false });
-    }
-    if (this.is(TokenType.NULL)) {
-      this.advance();
-      return new ASTNode(NodeType.Literal, { value: null });
-    }
-    if (this.is(TokenType.IDENT)) {
-      return this.parseIdentifierOrExpression();
-    }
+    if (this.is(TokenType.LBRACE)) return this.parseObjectLiteral();
+    if (this.is(TokenType.LBRACKET)) return this.parseArrayLiteral();
+
+    const literal = this.tryParseLiteral();
+    if (literal) return literal;
+
+    if (this.is(TokenType.IDENT)) return this.parseIdentifierOrExpression();
 
     throw new Error(
       `Unexpected token ${this.current()?.type} in value at line ${this.current()?.line}`
@@ -612,32 +609,18 @@ export class Parser {
 
     let value;
     if (this.is(TokenType.LBRACE)) {
-      // Expression prop: name={expression}
-      this.advance(); // consume {
+      this.advance();
       value = this.parseExpression();
       this.expect(TokenType.RBRACE);
-    } else if (this.is(TokenType.STRING)) {
-      // String prop: name="value"
-      const token = this.advance();
-      value = new ASTNode(NodeType.Literal, { value: token.value, raw: token.raw });
-    } else if (this.is(TokenType.NUMBER)) {
-      // Number prop: name=123
-      const token = this.advance();
-      value = new ASTNode(NodeType.Literal, { value: token.value });
-    } else if (this.is(TokenType.TRUE)) {
-      this.advance();
-      value = new ASTNode(NodeType.Literal, { value: true });
-    } else if (this.is(TokenType.FALSE)) {
-      this.advance();
-      value = new ASTNode(NodeType.Literal, { value: false });
-    } else if (this.is(TokenType.NULL)) {
-      this.advance();
-      value = new ASTNode(NodeType.Literal, { value: null });
-    } else if (this.is(TokenType.IDENT)) {
-      // Identifier prop: name=someVar
-      value = this.parseIdentifierOrExpression();
     } else {
-      throw this.createError(`Unexpected token in prop value: ${this.current()?.type}`);
+      value = this.tryParseLiteral();
+      if (!value) {
+        if (this.is(TokenType.IDENT)) {
+          value = this.parseIdentifierOrExpression();
+        } else {
+          throw this.createError(`Unexpected token in prop value: ${this.current()?.type}`);
+        }
+      }
     }
 
     return new ASTNode(NodeType.Property, { name: name.value, value });
@@ -885,80 +868,39 @@ export class Parser {
   }
 
   /**
-   * Parse OR expression
-   */
-  parseOrExpression() {
-    let left = this.parseAndExpression();
-
-    while (this.is(TokenType.OR)) {
-      this.advance();
-      const right = this.parseAndExpression();
-      left = new ASTNode(NodeType.BinaryExpression, { operator: '||', left, right });
-    }
-
-    return left;
-  }
-
-  /**
-   * Parse AND expression
+   * Binary operator precedence table (higher = binds tighter)
    */
-  parseAndExpression() {
-    let left = this.parseComparisonExpression();
-
-    while (this.is(TokenType.AND)) {
-      this.advance();
-      const right = this.parseComparisonExpression();
-      left = new ASTNode(NodeType.BinaryExpression, { operator: '&&', left, right });
-    }
-
-    return left;
-  }
+  static BINARY_OPS = [
+    { ops: [TokenType.OR], name: 'or' },
+    { ops: [TokenType.AND], name: 'and' },
+    { ops: [TokenType.EQEQ, TokenType.EQEQEQ, TokenType.NEQ, TokenType.NEQEQ,
+            TokenType.LT, TokenType.GT, TokenType.LTE, TokenType.GTE], name: 'comparison' },
+    { ops: [TokenType.PLUS, TokenType.MINUS], name: 'additive' },
+    { ops: [TokenType.STAR, TokenType.SLASH, TokenType.PERCENT], name: 'multiplicative' }
+  ];
 
   /**
-   * Parse comparison expression
+   * Generic binary expression parser using precedence climbing
    */
-  parseComparisonExpression() {
-    let left = this.parseAdditiveExpression();
-
-    while (this.isAny(TokenType.EQEQ, TokenType.EQEQEQ, TokenType.NEQ, TokenType.NEQEQ,
-                       TokenType.LT, TokenType.GT, TokenType.LTE, TokenType.GTE)) {
-      const operator = this.advance().value;
-      const right = this.parseAdditiveExpression();
-      left = new ASTNode(NodeType.BinaryExpression, { operator, left, right });
+  parseBinaryExpr(level = 0) {
+    if (level >= Parser.BINARY_OPS.length) {
+      return this.parseUnaryExpression();
     }
 
-    return left;
-  }
-
-  /**
-   * Parse additive expression
-   */
-  parseAdditiveExpression() {
-    let left = this.parseMultiplicativeExpression();
+    let left = this.parseBinaryExpr(level + 1);
+    const { ops } = Parser.BINARY_OPS[level];
 
-    while (this.isAny(TokenType.PLUS, TokenType.MINUS)) {
+    while (this.isAny(...ops)) {
       const operator = this.advance().value;
-      const right = this.parseMultiplicativeExpression();
+      const right = this.parseBinaryExpr(level + 1);
       left = new ASTNode(NodeType.BinaryExpression, { operator, left, right });
     }
 
     return left;
   }
 
-  /**
-   * Parse multiplicative expression
-   */
-  parseMultiplicativeExpression() {
-    let left = this.parseUnaryExpression();
-
-    while (this.isAny(TokenType.STAR, TokenType.SLASH, TokenType.PERCENT)) {
-      const operator = this.advance().value;
-      const right = this.parseUnaryExpression();
-      left = new ASTNode(NodeType.BinaryExpression, { operator, left, right });
-    }
-
-    return left;
-  }
+  /** Parse OR expression (entry point for binary expressions) */
+  parseOrExpression() { return this.parseBinaryExpr(0); }
 
   /**
    * Parse unary expression
@@ -1048,30 +990,9 @@ export class Parser {
       return new ASTNode(NodeType.SpreadElement, { argument });
     }
 
-    if (this.is(TokenType.NUMBER)) {
-      const token = this.advance();
-      return new ASTNode(NodeType.Literal, { value: token.value });
-    }
-
-    if (this.is(TokenType.STRING)) {
-      const token = this.advance();
-      return new ASTNode(NodeType.Literal, { value: token.value, raw: token.raw });
-    }
-
-    if (this.is(TokenType.TRUE)) {
-      this.advance();
-      return new ASTNode(NodeType.Literal, { value: true });
-    }
-
-    if (this.is(TokenType.FALSE)) {
-      this.advance();
-      return new ASTNode(NodeType.Literal, { value: false });
-    }
-
-    if (this.is(TokenType.NULL)) {
-      this.advance();
-      return new ASTNode(NodeType.Literal, { value: null });
-    }
+    // Try parsing a literal (NUMBER, STRING, TRUE, FALSE, NULL)
+    const literal = this.tryParseLiteral();
+    if (literal) return literal;
 
     // In expressions, SELECTOR tokens should be treated as IDENT
     // This happens when identifiers like 'selectedCategory' are followed by space in view context