jac-client 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

jac_client/docs/file-system/app.jac.md

@@ -1,121 +0,0 @@
-# The `app.jac` Entry Point
-
-Every Jac client project **must** have an `app.jac` file. This file serves as the entry point for your application and is required for the build system to work correctly.
-
-## Why `app.jac` is Required
-
-### Entry Point for the Build System
-
-When you run `jac serve app.jac`, the build system:
-1. Compiles `app.jac` to JavaScript
-2. Generates an entry file (`src/main.js`) that imports your `app` function:
-   ```javascript
-   import { app as App } from "./app.js";
-   ```
-3. Renders your app component in the browser
-
-**Without `app.jac`, the build system cannot find your application entry point.**
-
-## The `app()` Function
-
-The `app.jac` file **must** export an `app()` function. This function is:
-- The root component of your application
-- Automatically imported and rendered by the build system
-- The starting point for all your UI components
-
-### Required Structure
-
-Every `app.jac` file must contain:
-
-```jac
-cl {
-    def app() -> any {
-        return <div>
-            {/* Your application UI */}
-        </div>;
-    }
-}
-```
-
-### Minimal Example
-
-```jac
-cl {
-    def app() -> any {
-        return <div>
-            <h1>Hello, World!</h1>
-        </div>;
-    }
-}
-```
-
-## Key Requirements
-
-1. **File must be named `app.jac`**
-   - The build system specifically looks for this filename
-   - Located at the root of your project
-
-2. **Must contain `app()` function**
-   - Function name must be exactly `app`
-   - Must be defined inside a `cl { }` block
-   - Must return JSX (HTML-like syntax)
-
-3. **Must be a client function**
-   - Defined inside `cl { }` block
-   - This ensures it runs in the browser
-
-## Common Mistakes
-
-**Missing `app()` function:**
-```jac
-# ❌ WRONG - No app() function
-cl {
-    def HomePage() -> any {
-        return <div>Home</div>;
-    }
-}
-```
-
-**Wrong function name:**
-```jac
-# ❌ WRONG - Function named 'main' instead of 'app'
-cl {
-    def main() -> any {
-        return <div>App</div>;
-    }
-}
-```
-
-**Not in `cl` block:**
-```jac
-# ❌ WRONG - app() not in cl block
-def app() -> any {
-    return <div>App</div>;
-}
-```
-
-## Project Structure
-
-Your project structure should look like this:
-
-```
-my-app/
-├── app.jac              # ✅ Required entry point
-├── package.json
-├── vite.config.js
-└── ...
-```
-
-## Running Your App
-
-To start your application:
-
-```bash
-jac serve app.jac
-```
-
-This command compiles `app.jac`, creates the build entry point, and serves your app at `http://localhost:8000/page/app`.
-
----
-
-**Remember**: `app.jac` with `app()` function is **required** for every Jac client project. Without it, your application cannot start!

jac_client/docs/file-system/backend-frontend.md

@@ -1,217 +0,0 @@
-# Separating Backend and Frontend Code
-
-Jac allows you to organize your code by execution environment, making it easier to maintain and understand your application architecture.
-
-## File Extensions
-
-### `.jac` Files - Server-side Code
-
-Standard Jac files (`.jac`) contain your backend logic:
-- Node definitions
-- Walker implementations
-- Business logic
-- Data processing
-
-**Example: `app.jac`**
-```jac
-# Backend - Todo Node
-node Todo {
-    has text: str;
-    has done: bool = False;
-}
-
-# Backend - Walkers
-walker create_todo {
-    has text: str;
-
-    can create with `root entry {
-        new_todo = here ++> Todo(text=self.text);
-        report new_todo;
-    }
-}
-
-walker read_todos {
-    can read with `root entry {
-        visit [-->(`?Todo)];
-    }
-
-    can report_todos with Todo entry {
-        report here;
-    }
-}
-```
-
-### `.cl.jac` Files - Client-side Code (Optional)
-
-Client files (`.cl.jac`) contain your frontend components and logic. All code in these files is automatically treated as client-side code without requiring the `cl` keyword.
-
-**Example: `app.cl.jac`**
-```jac
-import from react {
-    useState
-}
-
-def app -> Any {
-    let [answer, setAnswer] = useState(0);
-
-    async def computeAnswer() -> None {
-        response = root spawn add(x=40, y=2);
-        result = response.reports;
-        setAnswer(result);
-    }
-
-    return <div>
-        <button onClick={computeAnswer}>
-            Click Me
-        </button>
-        <div>
-            <h1>
-                Answer:
-                <span>{answer}</span>
-            </h1>
-        </div>
-    </div>;
-}
-```
-
-## Mixed Backend and Frontend in Same File
-
-You can also combine backend and frontend code in the same `.jac` file using `cl` blocks:
-
-**Example: `app.jac` with both backend and frontend**
-```jac
-# Backend - Todo Node
-node Todo {
-    has text: str;
-    has done: bool = False;
-}
-
-# Backend - Walker
-walker create_todo {
-    has text: str;
-    can create with `root entry {
-        new_todo = here ++> Todo(text=self.text);
-        report new_todo;
-    }
-}
-
-# Frontend Components
-cl {
-    def app() -> any {
-        let [todos, setTodos] = useState([]);
-
-        async def addTodo() -> None {
-            response = root spawn create_todo(text="New task");
-            # Update UI
-        }
-
-        return <div>
-            {/* Your UI here */}
-        </div>;
-    }
-}
-```
-
-## Key Benefits
-
-### 1. No `cl` Keyword Required in `.cl.jac` Files
-
-In `.cl.jac` files, you don't need to prefix declarations with `cl`:
-- All code is compiled for the client environment
-- Cleaner syntax for frontend-only files
-
-### 2. Clear Separation of Concerns
-
-**Option 1: Separate Files**
-```
-my-app/
-├── app.jac       # Server-side: walkers, nodes, business logic
-└── app.cl.jac    # Client-side: components, UI, event handlers
-```
-
-**Option 2: Single File with `cl` Blocks**
-```jac
-# Backend code (no cl keyword)
-node Todo { ... }
-walker create_todo { ... }
-
-# Frontend code (cl block)
-cl {
-    def app() -> any { ... }
-}
-```
-
-### 3. Seamless Integration
-
-Client code can invoke server walkers using `root spawn`:
-
-```jac
-# In app.cl.jac or cl block
-async def computeAnswer() -> None {
-    response = root spawn create_todo(text="Task 1");  # Calls walker from app.jac
-    result = response.reports;
-    setAnswer(result);
-}
-```
-
-## Best Practices
-
-1. **Keep backend logic in `.jac` files**: Data models, business rules, and walker implementations
-2. **Keep frontend logic in `.cl.jac` files or `cl` blocks**: React components, UI state, event handlers
-3. **Use `root spawn` for client-server communication**: Clean API between frontend and backend
-4. **Organize by feature**: Group related `.jac` and `.cl.jac` files together
-
-## Project Structure Examples
-
-### Simple Structure
-```
-my-app/
-├── app.jac          # Backend: nodes and walkers
-└── app.cl.jac        # Frontend: React components
-```
-
-### Feature-Based Structure
-```
-my-app/
-├── app.jac           # Main backend logic
-├── app.cl.jac        # Main frontend entry
-├── todos/
-│   ├── todos.jac     # Todo backend logic
-│   └── todos.cl.jac  # Todo frontend components
-└── auth/
-    ├── auth.jac      # Auth backend logic
-    └── auth.cl.jac   # Auth frontend components
-```
-
-### Mixed Structure (Single Files)
-```
-my-app/
-├── app.jac           # Backend + Frontend in one file
-├── todos.jac         # Todo feature (backend + frontend)
-└── auth.jac          # Auth feature (backend + frontend)
-```
-
-## When to Use Each Approach
-
-### Use Separate Files (`.jac` + `.cl.jac`)
-- Large applications with clear separation
-- Team workflows where backend/frontend are separate
-- When you want explicit file-based organization
-
-### Use Single File with `cl` Blocks
-- Small to medium applications
-- When backend and frontend are tightly coupled
-- Quick prototypes and demos
-- When you prefer fewer files
-
-## Examples
-
-See working examples in the codebase:
-- [`basic-full-stack/`](../../examples/basic-full-stack/) - Mixed backend/frontend in single file
-- [`full-stack-with-auth/`](../../examples/full-stack-with-auth/) - Complete full-stack application
-
-## Related Documentation
-
-- [Nested Folder Imports](nested-imports.md)
-- [Import System](../imports.md)
-- [Lifecycle Hooks](../lifecycle-hooks.md)

jac_client/docs/file-system/intro.md

@@ -1,72 +0,0 @@
-# File System Organization
-
-Jac client supports flexible file organization patterns that allow you to structure your code for maintainability and scalability.
-
-## Overview
-
-This guide covers two main aspects of file organization:
-
-1. **Separating Backend and Frontend Code** - Organizing server-side and client-side logic
-2. **Nested Folder Imports** - Managing imports across multiple directory levels
-
-## Quick Start
-
-### Backend/Frontend Separation
-
-Jac allows you to organize code by execution environment:
-- Use `.jac` files for backend logic (nodes, walkers)
-- Use `.cl.jac` files for frontend-only code
-- Or mix both in the same file using `cl` blocks
-
-**Example:**
-```jac
-# Backend
-node Todo { has text: str; }
-
-# Frontend
-cl {
-    def app() -> any {
-        return <div>Hello</div>;
-    }
-}
-```
-
-### Nested Folder Imports
-
-Jac preserves folder structure during compilation, allowing you to organize code in nested folders:
-
-**Example:**
-```jac
-# From level1/Button.jac importing from root
-cl import from ..ButtonRoot { ButtonRoot }
-
-# From root importing from level1
-cl import from .level1.Button { Button }
-```
-
-## Guides
-
-- **[The `app.jac` Entry Point](app.jac.md)** - Required entry point file and `app()` function
-- **[Backend/Frontend Separation](backend-frontend.md)** - Complete guide to organizing server and client code
-- **[Nested Folder Imports](nested-imports.md)** - Guide to managing imports across directory levels
-
-## Examples
-
-Working examples demonstrating file organization:
-
-- [`nested-basic/`](../../examples/nested-folders/nested-basic/) - Simple nested folder structure
-- [`nested-advance/`](../../examples/nested-folders/nested-advance/) - Advanced multi-level nesting
-
-Run any example:
-
-```bash
-cd jac-client/jac_client/examples/nested-folders/<example-name>
-npm install
-jac serve app.jac
-```
-
-## Related Documentation
-
-- [Import System](../imports.md)
-- [Styling](../styling/intro.md)
-- [Asset Serving](../asset-serving/intro.md)