rip-lang 3.0.2 → 3.2.0

package/CHANGELOG.md

@@ -7,6 +7,49 @@ All notable changes to Rip will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.1.0] - 2026-02-08
+
+### Rip UI — Zero-Build Reactive Web Framework
+
+Rip UI inverts the traditional web development model. Instead of building and
+bundling on the server, the 40KB Rip compiler ships to the browser. Components
+are delivered as `.rip` source files, stored in a browser-local Virtual File
+System, compiled on demand, and rendered with fine-grained DOM updates.
+
+**Component model** — Two keywords added to the language:
+
+- `component` — Declares an anonymous ES6 class with reactive props, computed
+  values, effects, methods, and lifecycle hooks. `@` properties become props
+  the parent can set. `:=` creates signals, `~=` creates computed values.
+- `render` — Defines a Pug/Jade-like template DSL inside a component. Tags are
+  bare identifiers, classes use dot notation (`div.card.active`), dynamic
+  classes use dot-parens (`div.("active" if @selected)`), and events use
+  `@click: handler`. No virtual DOM — each reactive binding creates a direct
+  effect that updates exactly the DOM nodes it touches.
+
+**Framework modules** (all in `packages/ui/`):
+
+| Module | Role |
+|--------|------|
+| `stash.js` | Deep reactive state tree with path-based navigation |
+| `vfs.js` | Browser-local Virtual File System with file watchers |
+| `router.js` | File-based router (URL ↔ VFS paths, History API) |
+| `renderer.js` | Component lifecycle, layout nesting, route transitions |
+| `ui.js` | `createApp` entry point, re-exports everything |
+
+**Compiler changes** (`src/components.js`, 1,193 lines):
+
+- 22 methods installed on `CodeGenerator.prototype` via `installComponentSupport()`
+- Categorizes component body into state, computed, readonly, methods, effects, render
+- Emits fine-grained DOM creation (`_create()`) and reactive setup (`_setup()`)
+- Block factories for conditionals and loops with disposable effects
+- Keyed reconciliation for list rendering
+- Component runtime emitted only when `component` keyword is used
+
+**No build step. No bundler. No configuration files.**
+
+---
+
 ## [3.0.0] - 2026-02-07
 
 ### Complete Rewrite
@@ -27,8 +70,6 @@ Rip 3.0 is a ground-up rewrite of the entire compiler pipeline. Every component
 #### Removed
 - Postfix spread/rest (`x...`) — use prefix `...x` (ES6)
 - Prototype access (`x::y`, `x?::y`) — use `.prototype` or class syntax
-- Soak call sugar (`fn?(arg)`) — use `fn?.(arg)` (ES6 optional call)
-- Soak index sugar (`arr?[i]`) — use `arr?.[i]` (ES6 optional index)
 - `is not` contraction — use `isnt`
 
 #### Added
@@ -37,15 +78,16 @@ Rip 3.0 is a ground-up rewrite of the entire compiler pipeline. Every component
 - `as!` async shorthand: `for x as! iterable` (shorthand for `for await x as iterable`)
 
 #### Kept
-- Existence check: `x?` compiles to `(x != null)`
+- Existence check: `x?` compiles to `(x != null)` — works after any expression
 - All reactive operators: `:=`, `~=`, `~>`, `=!`
 - Dammit operator: `x!` compiles to `await x()`
-- Optional chaining: `?.`, `?.[]`, `?.()` (ES6 dot-form only)
+- Optional chaining: `?.`, `?.[]`, `?.()` (ES6 dot-form)
+- Optional chaining shorthand: `?[]`, `?()` (compiles to `?.[]`, `?.()`)
 - Nullish coalescing: `??`
 - All other CoffeeScript-compatible syntax
 
 ### Tests
-- 1,048 tests passing (100%)
+- 1,073 tests passing (100%)
 - 25 test files across all language features
 
 ---

package/README.md

@@ -9,9 +9,9 @@
 </p>
 
 <p align="center">
-  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-3.0.0-blue.svg" alt="Version"></a>
+  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-3.1.0-blue.svg" alt="Version"></a>
   <a href="#zero-dependencies"><img src="https://img.shields.io/badge/dependencies-ZERO-brightgreen.svg" alt="Dependencies"></a>
-  <a href="#"><img src="https://img.shields.io/badge/tests-1048%2F1048-brightgreen.svg" alt="Tests"></a>
+  <a href="#"><img src="https://img.shields.io/badge/tests-1130%2F1130-brightgreen.svg" alt="Tests"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green.svg" alt="License"></a>
 </p>
 
@@ -40,6 +40,7 @@ get '/users/:id' ->                 # RESTful API endpoint, comma-less
 - **Modern output** — ES2022 with native classes, `?.`, `??`, modules
 - **New operators** — `!`, `!?`, `//`, `%%`, `=~`, `.new()`, and more
 - **Reactive operators** — `:=`, `~=`, `~>` as language syntax
+- **Optional types** — `::` annotations, `::=` aliases, `.d.ts` emission
 - **Zero dependencies** — everything included, even the parser generator
 - **Self-hosting** — `bun run parser` rebuilds the compiler from source
 
@@ -137,6 +138,27 @@ State, computed values, and effects as language operators:
 
 ---
 
+### Types (Optional)
+
+Type annotations are erased at compile time — zero runtime cost:
+
+```coffee
+def greet(name:: string):: string        # Typed function
+  "Hello, #{name}!"
+
+User ::= type                            # Structural type
+  id: number
+  name: string
+
+enum HttpCode                            # Runtime enum
+  ok = 200
+  notFound = 404
+```
+
+Compiles to `.js` (types erased) + `.d.ts` (types preserved) — full IDE support via TypeScript Language Server. See [docs/RIP-TYPES.md](docs/RIP-TYPES.md).
+
+---
+
 ## Operators
 
 | Operator | Example | What it does |
@@ -147,6 +169,7 @@ State, computed values, and effects as language operators:
 | `?` (existence) | `x?` | True if `x != null` |
 | `?:` (ternary) | `x > 0 ? 'yes' : 'no'` | JS-style ternary expression |
 | `?.` `?.[]` `?.()` | `a?.b` `a?.[0]` `a?.()` | Optional chaining (ES6) |
+| `?[]` `?()` | `a?[0]` `a?(x)` | Optional chaining shorthand |
 | `??` | `a ?? b` | Nullish coalescing |
 | `...` (spread) | `[...items, last]` | Prefix spread (ES6) |
 | `//` | `7 // 2` | Floor division |
@@ -202,6 +225,27 @@ Rip's reactivity is framework-agnostic — use it with React, Vue, Svelte, or va
 
 ---
 
+## Rip UI
+
+Ship the 40KB Rip compiler to the browser. Components are `.rip` source files, compiled on demand, rendered with fine-grained reactivity. No build step. No bundler.
+
+```coffee
+Counter = component
+  @count := 0
+
+  render
+    div.counter
+      h1 "Count: #{@count}"
+      button @click: (-> @count++), "+"
+      button @click: (-> @count--), "-"
+```
+
+Two keywords — `component` and `render` — are all the language adds. Everything else (`:=` state, `~=` computed, methods, lifecycle) is standard Rip.
+
+See [@rip-lang/ui](packages/ui/) for the full framework: Virtual File System, file-based router, reactive stash, and component renderer.
+
+---
+
 ## vs CoffeeScript
 
 | Feature | CoffeeScript | Rip |
@@ -263,6 +307,7 @@ Rip includes optional packages for full-stack development:
 
 | Package | Purpose | Lines |
 |---------|---------|-------|
+| [@rip-lang/ui](packages/ui/) | Zero-build reactive web framework (VFS, router, components) | ~1,300 |
 | [@rip-lang/api](packages/api/) | HTTP framework (Sinatra-style routing, 37 validators) | ~1,050 |
 | [@rip-lang/server](packages/server/) | Multi-worker app server (hot reload, HTTPS, mDNS) | ~1,210 |
 | [@rip-lang/db](packages/db/) | DuckDB server with official UI (pure Bun FFI) | ~1,740 |
@@ -303,7 +348,7 @@ rip file.rip           # Run
 rip -c file.rip        # Compile
 rip -t file.rip        # Tokens
 rip -s file.rip        # S-expressions
-bun run test           # 1048 tests
+bun run test           # 1073 tests
 bun run parser         # Rebuild parser
 bun run browser        # Build browser bundle
 ```

package/bin/rip

@@ -25,6 +25,7 @@ Usage:
 
 Options:
   -c, --compile       Show compiled JavaScript output
+  -d, --dts           Generate .d.ts type declaration file
   -h, --help          Show this help message
   -o, --output <file> Write JavaScript to file
   -q, --quiet         Suppress headers
@@ -44,6 +45,8 @@ Examples:
   rip -t example.rip            # Show ONLY tokens
   rip -s -c example.rip         # Show s-expressions AND JavaScript
   rip -s -t -c example.rip      # Show everything (full debug mode)
+  rip -d example.rip            # Generate example.d.ts
+  rip -cd example.rip           # Compile JS and generate .d.ts
   rip -q -c example.rip         # Just the JS, no headers (for piping)
   rip -w                        # Launch browser REPL (auto-opens)
   echo 'x = 1 + 2' | rip -c     # Compile from stdin
@@ -142,12 +145,14 @@ async function main() {
   const showTokens = ripOptions.includes('-t') || ripOptions.includes('--tokens');
   const showSExpr = ripOptions.includes('-s') || ripOptions.includes('--sexpr');
   const showCompiled = ripOptions.includes('-c') || ripOptions.includes('--compile');
+  const generateDts = ripOptions.includes('-d') || ripOptions.includes('--dts');
   const quiet = ripOptions.includes('-q') || ripOptions.includes('--quiet');
 
   const options = {
     showTokens,
     showSExpr,
-    quiet
+    quiet,
+    types: generateDts ? 'emit' : undefined
   };
 
   // Find input file and output file from ripOptions only
@@ -162,7 +167,7 @@ async function main() {
   }
 
   // If .rip file without compile flags → execute instead of compile
-  const hasCompileFlag = showCompiled || showTokens || showSExpr || outputFile;
+  const hasCompileFlag = showCompiled || showTokens || showSExpr || generateDts || outputFile;
   if (inputFile && inputFile.endsWith('.rip') && !hasCompileFlag) {
     // Check if file exists
     if (!existsSync(inputFile)) {
@@ -255,6 +260,23 @@ async function main() {
       }
       console.log(result.code);
     }
+
+    // Write .d.ts file
+    if (generateDts && result.dts) {
+      if (inputFile) {
+        let dtsFile = inputFile.replace(/\.rip$/, '.d.ts');
+        writeFileSync(dtsFile, result.dts, 'utf-8');
+        if (!options.quiet) {
+          console.log(`Generated ${dtsFile}`);
+        }
+      } else {
+        // stdin — print .d.ts to stdout
+        if (!options.quiet) {
+          console.log(`// == Type declarations == //\n`);
+        }
+        console.log(result.dts);
+      }
+    }
   } catch (error) {
     console.error('Compilation Error:', error.message);
     if (error.stack) {

package/docs/RIP-INTERNALS.md

@@ -63,7 +63,7 @@ console.log(code);
 
 | Feature | CoffeeScript | Rip |
 |---------|-------------|------|
-| Optional chaining | 4 soak operators | ES6 `?.` / `?.[]` / `?.()` |
+| Optional chaining | 4 soak operators | ES6 `?.` / `?.[]` / `?.()` + shorthand `?[]` / `?()` |
 | Ternary | No | `x ? a : b` |
 | Regex features | Basic | Ruby-style (`=~`, indexing, captures in `_`) |
 | Async shorthand | No | Dammit operator (`!`) |
@@ -90,18 +90,22 @@ console.log(code);
 ## The Pipeline
 
 ```
-Source Code  →  Lexer  →  Parser  →  S-Expressions  →  Codegen  →  JavaScript
-                (1,542)    (352)       (simple arrays)     (3,148)      (ES2022)
+Source Code  →  Lexer  →  emitTypes  →  Parser  →  S-Expressions  →  Codegen  →  JavaScript
+                (1,866)    (types.js)    (356)       (simple arrays)     (3,219)      (ES2022)
+                              ↓
+                           file.d.ts (when types: "emit")
 ```
 
 ## Key Files
 
 | File | Purpose | Lines | Modify? |
 |------|---------|-------|---------|
-| `src/lexer.js` | Lexer + Rewriter | 1,542 | Yes |
-| `src/compiler.js` | Compiler + Code Generator | 3,148 | Yes |
-| `src/parser.js` | Generated parser | 352 | No (auto-gen) |
-| `src/grammar/grammar.rip` | Grammar specification | 887 | Yes (carefully) |
+| `src/lexer.js` | Lexer + Rewriter | 1,866 | Yes |
+| `src/compiler.js` | Compiler + Code Generator | 3,219 | Yes |
+| `src/types.js` | Type System (lexer sidecar) | 718 | Yes |
+| `src/components.js` | Component System (compiler sidecar) | ~1,240 | Yes |
+| `src/parser.js` | Generated parser | 356 | No (auto-gen) |
+| `src/grammar/grammar.rip` | Grammar specification | 934 | Yes (carefully) |
 | `src/grammar/solar.rip` | Parser generator | 1,001 | No |
 
 ## Example Flow
@@ -240,6 +244,12 @@ S-expressions are simple arrays that serve as Rip's intermediate representation
 ['class', name, parent?, ...members]
 ```
 
+### Types
+```javascript
+['enum', name, body]              // Enum declaration (runtime JS)
+// Type aliases, interfaces → handled by rewriter, never reach parser
+```
+
 ### Ranges & Slicing
 ```javascript
 ['..', from, to]      // Inclusive range
@@ -298,8 +308,6 @@ The `!` suffix on `as` in for-loops (`as!`) emits `FORASAWAIT` instead of `FORAS
 |---------|-----------|-------------|
 | Postfix spread/rest | `x...` | `...x` (ES6 prefix only) |
 | Prototype access | `x::y`, `x?::y` | Direct `.prototype` or class syntax; `::` reserved for type annotations |
-| Soak call sugar | `x?(args)` | `x?.(args)` (ES6 optional call) |
-| Soak index sugar | `x?[i]` | `x?.[i]` (ES6 optional index) |
 | `is not` contraction | `x is not y` | `x isnt y` |
 
 ### Added
@@ -395,13 +403,15 @@ counter = ->
 | `x ?? y` | `x ?? y` |
 | `x ??= 10` | `x ??= 10` |
 
-Optional chaining uses ES6 syntax:
+Optional chaining uses ES6 syntax (both forms supported):
 
 | Syntax | Compiles To |
 |--------|-------------|
 | `obj?.prop` | `obj?.prop` |
 | `arr?.[0]` | `arr?.[0]` |
 | `fn?.(x)` | `fn?.(x)` |
+| `arr?[0]` | `arr?.[0]` |
+| `fn?(x)` | `fn?.(x)` |
 
 ## Range Optimization
 
@@ -458,8 +468,6 @@ The `Compiler` class's lexer adapter reconstructs `new String()` wrapping from t
 |-----------|--------|--------|
 | `generatePrototype` | `::` | Feature removed from lexer |
 | `generateOptionalPrototype` | `?::` | Feature removed from lexer |
-| `generateSoakIndex` | `?[]` | Replaced by `optindex` / `?.[]` |
-| `generateSoakCall` | `?call` | Replaced by `optcall` / `?.()` |
 
 ## Renamed: `for-from` → `for-as`
 
@@ -560,7 +568,6 @@ bun src/compare-compilers.js
 
 # 9. Future Work
 
-- `::` token for type annotations (see `docs/RIP-TYPES.md`)
 - Comment preservation for source maps
 - Parser update to read `.data` directly instead of `new String()` properties
 - Once parser supports `.data`, the `meta()`/`str()` helpers become trivial to update
@@ -569,8 +576,9 @@ bun src/compare-compilers.js
 
 **See Also:**
 - [RIP-LANG.md](RIP-LANG.md) — Language reference
+- [RIP-TYPES.md](RIP-TYPES.md) — Type system specification
 - [RIP-REACTIVITY.md](RIP-REACTIVITY.md) — Reactivity deep dive
 
 ---
 
-*Rip 3.0.0 — 1,048 tests passing — Zero dependencies — Self-hosting — ~7,700 LOC*
+*Rip 3.0 — 1,130 tests passing — Zero dependencies — Self-hosting — ~8,800 LOC*

package/docs/RIP-LANG.md

@@ -17,9 +17,10 @@ Rip is a modern reactive language that compiles to ES2022 JavaScript. It combine
 9. [Regex Features](#9-regex-features)
 10. [Server-Side Development](#10-server-side-development)
 11. [CLI Tools & Scripts](#11-cli-tools--scripts)
-12. [JavaScript Interop](#12-javascript-interop)
-13. [Common Patterns](#13-common-patterns)
-14. [Quick Reference](#14-quick-reference)
+12. [Types](#12-types)
+13. [JavaScript Interop](#13-javascript-interop)
+14. [Common Patterns](#14-common-patterns)
+15. [Quick Reference](#15-quick-reference)
 
 ---
 
@@ -273,6 +274,7 @@ Multiple lines
 | `?` (postfix) | `a?` | Existence check (`a != null`) |
 | `?` (ternary) | `a ? b : c` | Ternary conditional |
 | `?.` `?.[]` `?.()` | `a?.b` `a?.[0]` `a?.()` | Optional chaining (ES6) |
+| `?[]` `?()` | `a?[0]` `a?(x)` | Optional chaining shorthand |
 | `??` | `a ?? b` | Nullish coalescing |
 
 ## Rip-Specific Operators
@@ -311,10 +313,14 @@ x ||= val    # x = x || val
 ## Optional Chaining
 
 ```coffee
-# ES6 optional chaining (dot required)
+# ES6 optional chaining (with dot)
 user?.profile?.name
 arr?.[0]
 fn?.(arg)
+
+# Shorthand (without dot — same behavior)
+arr?[0]       # Compiles to arr?.[0]
+fn?(arg)      # Compiles to fn?.(arg)
 ```
 
 ## Ternary Operator
@@ -919,7 +925,41 @@ for filename in files
 
 ---
 
-# 12. JavaScript Interop
+# 12. Types
+
+Rip supports an optional, compile-time-only type system. Types are erased from
+`.js` output and preserved in `.d.ts` declaration files.
+
+```coffee
+# Type annotations (::)
+count:: number = 0
+def greet(name:: string):: string
+  "Hello, #{name}!"
+
+# Type aliases (::=)
+ID ::= number
+User ::= type
+  id: number
+  name: string
+
+# Interfaces
+interface Animal
+  name: string
+
+# Enums (emit runtime JS)
+enum HttpCode
+  ok = 200
+  notFound = 404
+```
+
+Types use `=>` for function type arrows and `->` for code arrows. This
+disambiguates type expressions from function bodies cleanly.
+
+For the complete type system specification, see [RIP-TYPES.md](RIP-TYPES.md).
+
+---
+
+# 13. JavaScript Interop
 
 ```coffee
 # Import any npm package
@@ -949,7 +989,7 @@ const { code } = compile('x = 42');
 
 ---
 
-# 13. Common Patterns
+# 14. Common Patterns
 
 ## Error Handling
 
@@ -1031,7 +1071,7 @@ class EventEmitter
 
 ---
 
-# 14. Quick Reference
+# 15. Quick Reference
 
 ## Syntax Cheat Sheet
 
@@ -1123,4 +1163,4 @@ count = 10  # Logs: "Count: 10, Doubled: 20"
 
 ---
 
-*Rip 3.0.0 — 1,048 tests passing — Zero dependencies — Self-hosting — ~7,700 LOC*
+*Rip 3.0 — 1,073 tests passing — Zero dependencies — Self-hosting — ~7,700 LOC*

package/docs/RIP-REACTIVITY.md

@@ -286,3 +286,24 @@ Rip's reactivity system:
 ✅ **Extra utilities** — `.lock()`, `.read()`, `.kill()` that others lack <br>
 
 **On par with Vue/Solid. Better than React. A fraction of the size.**
+
+---
+
+## Types and Reactivity
+
+Reactive operators work with Rip's optional type system:
+
+```coffee
+count:: number := 0               # Typed state
+doubled:: number ~= count * 2     # Typed computed
+```
+
+Type annotations are erased from `.js` output. In `.d.ts` output, reactive
+state emits `Signal<T>` and computed values emit `Computed<T>`:
+
+```ts
+declare const count: Signal<number>;
+declare const doubled: Computed<number>;
+```
+
+See [RIP-TYPES.md](RIP-TYPES.md) for the complete type system specification.