jac-client 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

jac_client/examples/all-in-one/src/hooks/useBudget.jac

@@ -0,0 +1,116 @@
+# Custom hook for budget operations
+# Demonstrates: custom hooks, useState, array methods
+
+cl import from react { useCallback, useMemo }
+
+cl {
+    # Main budget management hook
+    def:pub useBudget() -> dict {
+        # Simple useState - no complex localStorage hook
+        [transactions, setTransactions] = useState([]);
+
+        # Add a new transaction
+        def addTransaction(description: str, amount: float, category: str, txType: str, isBusiness: bool, clientName: str) -> None {
+            newTx = {
+                "id": Date.now().toString(),
+                "description": description,
+                "amount": amount,
+                "category": category,
+                "type": txType,
+                "date": Reflect.construct(Date, []).toISOString(),
+                "isBusinessTransaction": isBusiness,
+                "clientName": clientName if clientName != "" else None
+            };
+            setTransactions(transactions.concat([newTx]));
+        }
+
+        # Delete a transaction by ID
+        def deleteTransaction(id: str) -> None {
+            filtered = transactions.filter(lambda tx: dict -> bool {
+                return tx["id"] != id;
+            });
+            setTransactions(filtered);
+        }
+
+        # Calculate totals
+        totalIncome = 0.0;
+        totalExpenses = 0.0;
+        for tx in transactions {
+            if tx["type"] == "income" {
+                totalIncome = totalIncome + tx["amount"];
+            } else {
+                totalExpenses = totalExpenses + tx["amount"];
+            }
+        }
+        balance = totalIncome - totalExpenses;
+
+        # Calculate business/personal breakdown
+        businessIncome = 0.0;
+        businessExpenses = 0.0;
+        personalIncome = 0.0;
+        personalExpenses = 0.0;
+
+        for tx in transactions {
+            isBusiness = tx["isBusinessTransaction"] || false;
+            amount = tx["amount"];
+
+            if tx["type"] == "income" {
+                if isBusiness {
+                    businessIncome = businessIncome + amount;
+                } else {
+                    personalIncome = personalIncome + amount;
+                }
+            } else {
+                if isBusiness {
+                    businessExpenses = businessExpenses + amount;
+                } else {
+                    personalExpenses = personalExpenses + amount;
+                }
+            }
+        }
+
+        # Tax calculations
+        TAX_RATE = 0.20;
+        taxReserve = businessIncome * TAX_RATE;
+        netProfit = businessIncome - businessExpenses - taxReserve;
+
+        # Get expense breakdown by category (for chart)
+        def getExpensesByCategory() -> list {
+            categoryTotals = {};
+            for tx in transactions {
+                if tx["type"] == "expense" {
+                    cat = tx["category"];
+                    if categoryTotals[cat] {
+                        categoryTotals[cat] = categoryTotals[cat] + tx["amount"];
+                    } else {
+                        categoryTotals[cat] = tx["amount"];
+                    }
+                }
+            }
+            result = [];
+            for key in Object.keys(categoryTotals) {
+                result = result.concat([{
+                    "name": key,
+                    "value": categoryTotals[key]
+                }]);
+            }
+            return result;
+        }
+
+        return {
+            "transactions": transactions,
+            "addTransaction": addTransaction,
+            "deleteTransaction": deleteTransaction,
+            "totalIncome": totalIncome,
+            "totalExpenses": totalExpenses,
+            "balance": balance,
+            "expensesByCategory": getExpensesByCategory(),
+            "businessIncome": businessIncome,
+            "businessExpenses": businessExpenses,
+            "personalIncome": personalIncome,
+            "personalExpenses": personalExpenses,
+            "taxReserve": taxReserve,
+            "netProfit": netProfit
+        };
+    }
+}

jac_client/examples/all-in-one/src/hooks/useLocalStorage.jac

@@ -0,0 +1,36 @@
+# Custom hook for localStorage persistence
+# Demonstrates: custom hooks, try/except error handling, useEffect
+
+cl import from react { useEffect }
+
+cl {
+    # Custom hook for syncing state with localStorage
+    def useLocalStorage(key: str, initialValue: list) -> list {
+        # Initialize state with value from localStorage or default
+        [storedValue, setStoredValue] = useState(lambda -> any {
+            try {
+                item = window.localStorage.getItem(key);
+                if item {
+                    return JSON.parse(item);
+                }else{
+                    return initialValue;
+                }
+
+            } except Exception as e  {
+                console.log("Error reading from localStorage");
+                return initialValue;
+            }
+        });
+
+        # Update localStorage when state changes
+        useEffect(lambda -> None {
+            try {
+                window.localStorage.setItem(key, JSON.stringify(storedValue));
+            } except Exception as e {
+                console.log("Error saving to localStorage");
+            }
+        }, [key, storedValue]);
+
+        return [storedValue, setStoredValue];
+    }
+}

jac_client/examples/all-in-one/src/pages/BudgetPlanner.cl.jac

@@ -0,0 +1,70 @@
+# Budget Planner Page
+# Main application page with budget tracking features
+
+# Local JAC file imports
+cl import from ..context.BudgetContext { useBudgetContext }
+cl import from ..components.Header { Header }
+cl import from ..components.Summary { Summary }
+cl import from ..components.ProfitOverview { ProfitOverview }
+cl import from ..components.TransactionForm { TransactionForm }
+cl import from ..components.TransactionList { TransactionList }
+cl import from ..components.CategoryFilter { CategoryFilter }
+cl import from ..constants.categories { CATEGORY_COLORS }
+
+# cl import from "..components.PieChart.tsx" { PieChart }
+
+
+cl def:pub BudgetPlanner() -> any {
+        [filter, setFilter] = useState("ALL");
+        budget = useBudgetContext();
+
+        # Filter transactions based on selected category
+        filtered = budget["transactions"];
+        if filter != "ALL" {
+            filtered = filtered.filter(lambda tx: dict -> bool {
+                return tx["category"] == filter;
+            });
+        }
+
+        # Sort by date (newest first)
+        sorted = filtered.slice().sort(lambda a: dict, b: dict -> int {
+            return Reflect.construct(Date, [b["date"]]).getTime() - Reflect.construct(Date, [a["date"]]).getTime();
+        });
+
+        # Prepare chart data with colors
+        chartData = budget["expensesByCategory"].map(lambda item: dict -> dict {
+            return {
+                "name": item["name"],
+                "value": item["value"],
+                "color": CATEGORY_COLORS[item["name"]]
+            };
+        });
+
+        return <div className="app-container">
+            <Header />
+
+            <main className="main-content">
+                <div className="left-panel">
+                    <Summary />
+                    <ProfitOverview />
+                    <TransactionForm />
+                    <CategoryFilter
+                        selectedCategory={filter}
+                        onSelect={setFilter}
+                    />
+                    <TransactionList
+                        transactions={sorted}
+                        onDelete={budget["deleteTransaction"]}
+                    />
+                </div>
+
+                <div className="right-panel">
+                    # <PieChart
+                    #     data={chartData}
+                    #     title="Expense Breakdown"
+                    #     colors={CATEGORY_COLORS}
+                    # />
+                </div>
+            </main>
+        </div>;
+    }

jac_client/examples/all-in-one/src/pages/BudgetPlanner.jac

@@ -0,0 +1,126 @@
+# Features Test Page - Backend Logic
+# This file is intentionally kept empty to demonstrate the separation of concerns
+# where UI logic resides in .cl.jac files and backend walker logic in app.jac
+
+# All walker implementations for this feature are in src/app.jac
+# This demonstrates that you can have separate .jac files for different purposes
+# Features Test - Backend Walkers
+# This file demonstrates walker functionality for testing various JAC features
+
+import from datetime { datetime, timedelta }
+
+# Node definition for storing test data
+node TestData {
+    has message: str;
+    has count: int = 0;
+    has created_at: str = "";
+}
+
+# Walker: Create test data
+walker create_test_data {
+    has message: str;
+
+    can create with `root entry {
+        new_data = here ++> TestData(
+            message=self.message,
+            count=1,
+            created_at=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        );
+        report new_data;
+    }
+}
+
+# Walker: Read all test data
+walker read_test_data {
+    can read with `root entry {
+        visit [-->(`?TestData)];
+    }
+
+    can report_data with exit {
+        report here;
+    }
+}
+
+# Walker: Update test data
+walker update_test_data {
+    has new_message: str;
+
+    can update with TestData entry {
+        here.message = self.new_message;
+        here.count = here.count + 1;
+        report here;
+    }
+}
+
+# Walker: Delete test data
+walker delete_test_data {
+    can delete with TestData entry {
+        del here;
+        report {"status": "deleted"};
+    }
+}
+
+# Walker: String manipulation test
+walker test_string_methods {
+    has input_text: str;
+
+    can process with `root entry {
+        result = {
+            "original": self.input_text,
+            "uppercase": self.input_text.upper(),
+            "lowercase": self.input_text.lower(),
+            "capitalized": self.input_text.capitalize(),
+            "reversed": self.input_text[::-1],
+            "length": len(self.input_text),
+            "words": self.input_text.split(),
+            "trimmed": self.input_text.strip(),
+            "replaced": self.input_text.replace("test", "demo")
+        };
+        report result;
+    }
+}
+
+# Walker: Array/List operations test
+walker test_list_operations {
+    has numbers: list;
+
+    can process with `root entry {
+        result = {
+            "original": self.numbers,
+            "sorted": sorted(self.numbers),
+            "reversed": list(reversed(self.numbers)),
+            "sum": sum(self.numbers),
+            "max": max(self.numbers) if len(self.numbers) > 0 else 0,
+            "min": min(self.numbers) if len(self.numbers) > 0 else 0,
+            "length": len(self.numbers),
+            "doubled": [x * 2 for x in self.numbers]
+        };
+        report result;
+    }
+}
+
+# Walker: Complex data processing
+walker process_complex_data {
+    has items: list;
+
+    can process with `root entry {
+        processed = [];
+        for item in self.items {
+            processed.append({
+                "id": item.get("id", 0),
+                "name": item.get("name", "").upper(),
+                "value": item.get("value", 0) * 2,
+                "processed_at": datetime.now().strftime("%H:%M:%S")
+            });
+        }
+
+        result = {
+            "original_count": len(self.items),
+            "processed_count": len(processed),
+            "items": processed,
+            "total_value": sum([p["value"] for p in processed])
+        };
+
+        report result;
+    }
+}