round-core 0.1.2 → 0.1.4

package/README.md

@@ -73,9 +73,19 @@ A **signal** is a small reactive container.
 Round includes a CLI with a project initializer.
 
 ```bash
+# Install the CLI
+npm install round
+
+# Create a new app
 round init myapp
+
+# Navigate to the app directory
 cd myapp
+
+# Install dependencies
 npm install
+
+# Run the app
 npm run dev
 ```
 
@@ -163,6 +173,39 @@ effect(() => {
 name('Grace');
 ```
 
+### `asyncSignal(fetcher)`
+
+Create a signal that manages asynchronous data fetching.
+
+- It returns a signal that resolves to the data once fetched.
+- **`.pending`**: A reactive signal (boolean) indicating if the fetch is in progress.
+- **`.error`**: A reactive signal containing any error that occurred during fetching.
+- **`.refetch()`**: A method to manually trigger a re-fetch.
+
+```jsx
+import { asyncSignal } from 'round-core';
+
+const user = asyncSignal(async () => {
+    const res = await fetch('/api/user');
+    return res.json();
+});
+
+export function UserProfile() {
+    return (
+        <div>
+            {if(user.pending()){
+                <div>Loading...</div>
+            } else if(user.error()){
+                <div>Error: {user.error().message}</div>
+            } else {
+                <div>Welcome, {user().name}</div>
+            }}
+            <button onClick={() => user.refetch()}>Reload</button>
+        </div>
+    );
+}
+```
+
 ### `untrack(fn)`
 
 Run a function without tracking any signals it reads.
@@ -385,6 +428,25 @@ Notes:
 - The `switch` expression is automatically wrapped in a reactive tracker, ensuring that the view updates surgically when the condition (e.g., a signal) changes.
 - Each case handles its own rendering without re-running the parent component.
 
+### `try / catch`
+
+Round supports both static and **reactive** `try/catch` blocks inside JSX.
+
+- **Static**: Just like standard JS, but renders fragments.
+- **Reactive**: By passing a signal to `try(signal)`, the block will **automatically re-run** if the signal (or its dependencies) update. This is perfect for handling transient errors in async data.
+
+```jsx
+{try(user()) {
+    {if(user() && user().name) {
+        <div>Hello {user().name}</div>
+    } else if(user.pending()) {
+        <div>⏳ Loading...</div>
+    }}
+} catch(e) {
+    <div className="error"> Failed to load user: {e.message} </div>
+}}
+```
+
 ## Routing
 
 Round includes router primitives intended for SPA navigation. All route paths must start with a forward slash `/`.
@@ -452,26 +514,14 @@ const LazyWidget = lazy(() => import('./Widget'));
 
 ## Error handling
 
-Round aims to provide strong developer feedback:
-
-- Runtime error reporting with safe boundaries.
-- `ErrorBoundary` to catch render-time errors and show a fallback.
-
-### `ErrorBoundary`
-
-Wrap components to prevent the whole app from crashing if a child fails to render.
+Round JS favors individual error control and standard browser debugging:
 
-```jsx
-import { ErrorBoundary } from 'round-core';
-
-function DangerousComponent() {
-    throw new Error('Boom!');
-}
+1.  **Explict `try/catch`**: Use the JSX `try/catch` syntax to handle local component failures gracefully.
+2.  **Console-First Reporting**: Unhandled errors in component rendering or reactive effects are logged to the browser console with descriptive metadata (component name, render phase) and then allowed to propagate.
+3.  **No Intrusive Overlays**: Round has removed conflicting global error boundaries to ensure that your local handling logic always takes precedence and the developer experience remains clean.
 
-<ErrorBoundary fallback={(err) => <div className="error">Something went wrong: {err.message}</div>}>
-    <DangerousComponent />
-</ErrorBoundary>
-```
+Example of a descriptive console log:
+`[round] Error in phase "component.render" of component <UserProfile />: TypeError: Cannot read property 'avatar' of undefined`
 
 ## CLI
 

package/package.json

@@ -1,16 +1,22 @@
 {
     "name": "round-core",
-    "version": "0.1.2",
+    "version": "0.1.4",
     "description": "A lightweight frontend framework for SPA with signals and fine grained reactivity",
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
+    "main": "./src/index.js",
+    "types": "./src/index.d.ts",
     "readme": "README.md",
     "exports": {
-        ".": "./dist/index.js",
-        "./vite-plugin": "./dist/vite-plugin.js"
+        ".": {
+            "types": "./src/index.d.ts",
+            "default": "./src/index.js"
+        },
+        "./vite-plugin": {
+            "types": "./src/compiler/vite-plugin.d.ts",
+            "default": "./src/compiler/vite-plugin.js"
+        }
     },
     "files": [
-        "dist",
+        "src",
         "README.md",
         "LICENSE"
     ],
@@ -20,12 +26,11 @@
         "url": "https://github.com/ZtaMDev/RoundJS.git"
     },
     "bin": {
-        "round": "./dist/cli.js"
+        "round": "./src/cli.js"
     },
     "scripts": {
         "dev": "node ./src/cli.js dev --config ./test/main/round.config.json",
         "build": "node ./src/cli.js build --config ./test/main/round.config.json",
-        "build:core": "vite build -c vite.config.build.js",
         "bench": "bun run --cwd benchmarks bench",
         "bench:build": "bun run --cwd benchmarks bench:build",
         "bench:runtime": "bun run --cwd benchmarks bench:runtime"