dars-framework 1.1.8__tar.gz → 1.2.0__tar.gz

{dars_framework-1.1.8 → dars_framework-1.2.0}/MANIFEST.in

@@ -3,4 +3,5 @@ include LICENSE
 recursive-include dars/templates *
 recursive-include dars/docs *
 recursive-include dars *.json
-recursive-include dars *.md
+recursive-include dars *.md
+exclude LandingPage

{dars_framework-1.1.8/dars_framework.egg-info → dars_framework-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dars_framework
-Version: 1.1.8
+Version: 1.2.0
 Summary: Dars is a Python UI framework for building modern, interactive web apps with only Python code. Write your interface in Python, export it to static HTML/CSS/JS, and deploy anywhere.
 Author-email: ztamdev <zondax2009@gmail.com>
 License: MIT
@@ -11,4 +11,5 @@ Requires-Dist: uvicorn==0.35.0
 Requires-Dist: fastapi==0.116.1
 Requires-Dist: markdown2==2.5.4
 Requires-Dist: requests==2.32.5
+Requires-Dist: rjsmin==1.2.5
 Dynamic: license-file

{dars_framework-1.1.8 → dars_framework-1.2.0}/README.md

@@ -1,165 +1,220 @@
-<h1 align="center">Dars Framework</h1>
- 
-<p align="center">
-  <img src="./Dars-logo.png" alt="Dars Framework Logo" width="160" />
-</p>
-
-<p align="center">
-  <em>Dars is a Python UI framework for building modern, interactive web apps with Python code. Write your interface in Python, export it to static HTML/CSS/JS, and deploy anywhere.</em>
-</p>
-
-```bash
-pip install dars-framework
-```
-
-> Some Javascript or frontend stack required.
-
-Try dars without installing nothing just visit the [Dars Playground](https://dars-playground.vercel.app/)
-
-## How It Works
-- Build your UI using Python classes and components (like Text, Button, Container, Page, etc).
-- Preview instantly with hot-reload using `app.rTimeCompile()`.
-- Export your app to static web files with a single CLI command.
-- Use multipage, layouts, scripts, and more—see docs for advanced features.
-- For mor information visit the [Documentation](https://ztamdev.github.io/Dars-Framework/documentation.html)
-
-## Quick Example: Your First App
-> Note: this is an single page example but you can build multipage apps with Page component see the [Components Documentation](https://ztamdev.github.io/Dars-Framework/documentation.html#dars-components-documentation) to know more.
-
-```python
-from dars.all import *
-
-app = App()
-
-# Crear aplicación con sintaxis nueva (v1.0.3)
-container = Container(
-    Text(
-        "Hola Dars",
-        style={'font-size': '32px', 'color': '#333'}
-    ),
-    Button(
-        "Hacer clic",
-        style={'background-color': '#007bff', 'color': 'white'}
-    ),
-    style={
-        'display': 'flex',
-        'flex-direction': 'column',
-        'align-items': 'center',
-        'padding': '40px'
-    }
-)
-
-# Script para interactividad
-script = InlineScript("""
-document.addEventListener('DOMContentLoaded', function() {
-    const boton = document.querySelector('button');
-    boton.addEventListener('click', function() {
-        alert('Hola desde Dars.');
-    });
-});
-""")
-
-# Ensamblar aplicación
-app.set_root(container)
-app.add_script(script)
-
-if __name__ == "__main__":
-    app.rTimeCompile()  # Live preview at http://localhost:8000
-
-```
-
-## CLI Usage
-| Command                                 | What it does                               |
-|-----------------------------------------|--------------------------------------------|
-| `dars export my_app.py --format html`   | Export app to HTML/CSS/JS in `./my_app_web` |
-| `dars preview ./my_app_web`             | Preview exported app locally                |
-| `dars init my_project`                  | Create a new Dars project (also creates dars.config.json) |
-| `dars init --update`                    | Create/Update dars.config.json in current dir |
-| `dars build`                            | Build using dars.config.json (entry/outdir/format) |
-| `dars config validate`                  | Validate dars.config.json and print report   |
-| `dars info my_app.py`                   | Show info about your app                    |
-| `dars formats`                          | List supported export formats               |
-| `dars --help`                           | Show help and all CLI options               |
-
-## More
-
-- Visit dars [official website](https://ztamdev.github.io/Dars-Framework/)
-- Visit the dars official [Documentation](https://ztamdev.github.io/Dars-Framework/documentation.html) now on separate website.
-- Try dars without installing nothing just visit the [Dars Playground](https://dars-playground.vercel.app/)
-
-## Local Execution and Live Preview
-
-To test your app locally before exporting, use the hot-reload preview from any Python file that defines your app:
-
-```python
-if __name__ == "__main__":
-    app.rTimeCompile()
-```
-
-Then run your file directly:
-
-```bash
-python my_app.py
-```
-
-This will start a local server at http://localhost:8000 so you can view your app in the browser—no manual export needed. You can change the port with:
-
-```bash
-python my_app.py --port 8088
-```
-
----
-
-You can also use the CLI preview command on an exported app:
-
-```bash
-dars preview ./my_exported_app
-```
-
-This will start a local server at http://localhost:8000 to view your exported app in the browser.
-
----
-
-## Project Configuration (dars.config.json)
-
-Dars can read build/export settings from a `dars.config.json` at your project root. It is created automatically by `dars init`, and you can add it to existing projects with `dars init --update`.
-
-Example default:
-
-```json
-{
-  "entry": "main.py",
-  "format": "html",
-  "outdir": "dist",
-  "publicDir": null,
-  "include": [],
-  "exclude": ["**/__pycache__", ".git", ".venv", "node_modules"],
-  "bundle": false
-}
-```
-
-- `entry`: Python entry file. Used by `dars build` and `dars export config`.
-- `format`: Export format. Currently only `html` is supported.
-- `outdir`: Output directory. Used by `dars build` and default for `dars export` when not overridden.
-- `publicDir`: Folder (e.g., `public/` or `assets/`) copied into the output. If null, it is autodetected.
-- `include`/`exclude`: Basic filters for copying from `publicDir`.
-- `bundle`: Reserved for future use. CLI exports and build already bundle appropriately.
-
-Validate your config:
-
-```bash
-dars config validate
-```
-
-Build using config:
-
-```bash
-dars build
-```
-
-Export using the config entry and outdir:
-
-```bash
-dars export config --format html
-```
-
+<h1 align="center">Dars Framework</h1>
+ 
+<p align="center">
+  <img src="./Dars-logo.png" alt="Dars Framework Logo" width="200" />
+</p>
+
+<p align="center">
+  <em>Dars is a Python UI framework for building modern, interactive web apps with Python code. Write your interface in Python, export it to static HTML/CSS/JS, and deploy anywhere.</em>
+</p>
+
+```bash
+pip install dars-framework
+```
+
+> Some Javascript or frontend stack required.
+
+Try dars without installing nothing just visit the [Dars Playground](https://dars-playground.vercel.app/)
+
+## How It Works
+- Build your UI using Python classes and components (like Text, Button, Container, Page, etc).
+- Preview instantly with hot-reload using `app.rTimeCompile()`.
+- Export your app to static web files with a single CLI command.
+- Use multipage, layouts, scripts, and more—see docs for advanced features.
+- For mor information visit the [Documentation](https://ztamdev.github.io/Dars-Framework/documentation.html)
+
+## Quick Example: Your First App
+```python
+from dars.all import *
+
+app = App(title="Hello World", theme="dark")
+# Crear componentes
+index = Page(
+     Text(
+        text="Hello World",
+        style={
+            'font-size': '48px',
+            'color': '#2c3e50',
+            'margin-bottom': '20px',
+            'font-weight': 'bold',
+            'text-align': 'center'
+        }
+    ),
+    Text(
+        text="Hello World",
+        style={
+            'font-size': '20px',
+            'color': '#7f8c8d',
+            'margin-bottom': '40px',
+            'text-align': 'center'
+        }
+    ),
+
+    Button(
+        text="Click Me!",
+        on_click= dScript("alert('Hello World')"),
+        on_mouse_enter=dScript("this.style.backgroundColor = '#2980b9';"),
+        on_mouse_leave=dScript("this.style.backgroundColor = '#3498db';"),
+        style={
+            'background-color': '#3498db',
+            'color': 'white',
+            'padding': '15px 30px',
+            'border': 'none',
+            'border-radius': '8px',
+            'font-size': '18px',
+            'cursor': 'pointer',
+            'transition': 'background-color 0.3s'
+        }
+    ),
+    style={
+        'display': 'flex',
+        'flex-direction': 'column',
+        'align-items': 'center',
+        'justify-content': 'center',
+        'min-height': '100vh',
+        'background-color': '#f0f2f5',
+        'font-family': 'Arial, sans-serif'
+    }
+) 
+index.attr()
+app.add_page("index", index, title="Hello World", index=True)
+
+if __name__ == "__main__":
+    app.rTimeCompile()
+
+```
+
+---
+
+## Reactivity and State System
+
+**Dars Framework** includes a built-in **reactive state system** (`dState` / `cState`) that allows dynamic and modular DOM updates directly from Python.
+It enables fully event-driven interfaces without requiring manual JavaScript.
+
+### Key Concepts
+
+* **`dState(name, component, states)`**
+  Creates a reactive state controller bound to a specific component and a list of possible states.
+
+* **`cState(idx, mods=[...])`**
+  Defines rules (modifications) that are automatically applied when entering a specific state.
+
+* **`Mod` Helpers**
+  A compact way to modify DOM elements on state changes: `inc`, `dec`, `set`, `toggle_class`, `append_text`, `prepend_text`, `goto`, and more.
+
+* **Deferred Mutations**
+  Using `component.attr(..., defer=True)` or `component.mod(...)` inside a `cComp=True` state defers HTML updates until an event occurs, preventing authoring-time mutations.
+
+### Example Template
+
+A complete example demonstrating `dState`, `cState`, `Mod`, and deferred updates is available [here](https://github.com/ZtaMDev/Dars-Framework/blob/CrystalMain/dars/templates/examples/advanced/dState/state_mods_demo.py)
+
+<img width="384" height="187" alt="imagen" src="https://github.com/user-attachments/assets/7750ee7f-768f-48da-94df-2fa00339a99c" /> <img width="361" height="215" alt="imagen" src="https://github.com/user-attachments/assets/9b8a3e67-2424-49b4-aee0-9f1c0f747d66" />
+
+
+
+### Features
+
+* Reactive Mod system with compact `Mod` helpers
+* Unified event model — any component can use `on_*` props (`on_click`, `on_input`, `on_change`, etc.)
+* Deferred rendering for safer, predictable state transitions (`cComp=True`)
+* Navigation between states using `goto`, including relative moves (`'+1'`, `'-1'`)
+* Consistent, event-time mutation flow for reliable behavior
+
+---
+
+## CLI Usage
+| Command                                 | What it does                               |
+|-----------------------------------------|--------------------------------------------|
+| `dars export my_app.py --format html`   | Export app to HTML/CSS/JS in `./my_app_web` |
+| `dars preview ./my_app_web`             | Preview exported app locally                |
+| `dars init my_project`                  | Create a new Dars project (also creates dars.config.json) |
+| `dars init --update`                    | Create/Update dars.config.json in current dir |
+| `dars build`                            | Build using dars.config.json (entry/outdir/format) |
+| `dars config validate`                  | Validate dars.config.json and print report   |
+| `dars info my_app.py`                   | Show info about your app                    |
+| `dars formats`                          | List supported export formats               |
+| `dars --help`                           | Show help and all CLI options               |
+
+## More
+
+- Visit dars [official website](https://ztamdev.github.io/Dars-Framework/)
+- Visit the dars official [Documentation](https://ztamdev.github.io/Dars-Framework/documentation.html) now on separate website.
+- Try dars without installing nothing just visit the [Dars Playground](https://dars-playground.vercel.app/)
+
+## Local Execution and Live Preview
+
+To test your app locally before exporting, use the hot-reload preview from any Python file that defines your app:
+
+```python
+if __name__ == "__main__":
+    app.rTimeCompile()
+```
+
+Then run your file directly:
+
+```bash
+python my_app.py
+```
+
+This will start a local server at http://localhost:8000 so you can view your app in the browser—no manual export needed. You can change the port with:
+
+```bash
+python my_app.py --port 8088
+```
+
+---
+
+You can also use the CLI preview command on an exported app:
+
+```bash
+dars preview ./my_exported_app
+```
+
+This will start a local server at http://localhost:8000 to view your exported app in the browser.
+
+---
+
+## Project Configuration (dars.config.json)
+
+Dars can read build/export settings from a `dars.config.json` at your project root. It is created automatically by `dars init`, and you can add it to existing projects with `dars init --update`.
+
+Example default:
+
+```json
+{
+  "entry": "main.py",
+  "format": "html",
+  "outdir": "dist",
+  "publicDir": null,
+  "include": [],
+  "exclude": ["**/__pycache__", ".git", ".venv", "node_modules"],
+  "bundle": false
+}
+```
+
+- `entry`: Python entry file. Used by `dars build` and `dars export config`.
+- `format`: Export format. Currently only `html` is supported.
+- `outdir`: Output directory. Used by `dars build` and default for `dars export` when not overridden.
+- `publicDir`: Folder (e.g., `public/` or `assets/`) copied into the output. If null, it is autodetected.
+- `include`/`exclude`: Basic filters for copying from `publicDir`.
+- `bundle`: Reserved for future use. CLI exports and build already bundle appropriately.
+
+Validate your config:
+
+```bash
+dars config validate
+```
+
+Build using config:
+
+```bash
+dars build
+```
+
+Export using the config entry and outdir:
+
+```bash
+dars export config --format html
+```
+

{dars_framework-1.1.8 → dars_framework-1.2.0}/dars/all.py

@@ -53,6 +53,7 @@ from dars.dars_tests import *
 from dars.dars_tests.run_tests import run_app_tests, run_unit_tests, main
 # CLI (optional, for advanced usage)
 # from dars.cli.main import main as dars_cli_main
+from dars.core.state import dState, Mod
 
 __all__ = [
     'App', 'Component', 'EventManager',
@@ -64,4 +65,5 @@ __all__ = [
     'EventTypes', 'EventHandler', 'EventEmitter', 'EventManager', 'Markdown',
     '__version__',
     'run_app_tests', 'run_unit_tests', 'main',
+    'dState', 'Mod',
 ]

{dars_framework-1.1.8 → dars_framework-1.2.0}/dars/cli/main.py

@@ -291,6 +291,16 @@ class DarsExporter:
                 progress.update(task2, advance=80)
                 
                 if success:
+                    # Minification step for bundle
+                    try:
+                        from dars.security import minify_output_dir
+                        task3 = progress.add_task("Applying minification (bundle)", total=100)
+                        # Run minification
+                        count = minify_output_dir(output_path)
+                        progress.update(task3, completed=100)
+                    except Exception:
+                        # Do not fail export on minification errors
+                        pass
                     progress.update(task1, completed=100)
                     progress.update(task2, completed=100)
                     
@@ -527,14 +537,12 @@ def create_parser() -> argparse.ArgumentParser:
     """Creates the command line argument parser"""
     parser = argparse.ArgumentParser(
         description=translator.get('main_description'),
-        formatter_class=RichHelpFormatter,
-        epilog=""  # Remove epilog to avoid duplication
+        formatter_class=argparse.HelpFormatter,
+        epilog=""
     )
     parser.add_argument('-v', '--version', action='store_true', help='Show Dars version and release link')
     
-    # Add language parameter to the main parser
-    parser.add_argument('--lang', '-l', choices=['en', 'es'], default='en',
-                      help=translator.get('lang_help'))
+    # English-only: no language flag
     
     subparsers = parser.add_subparsers(dest='command', help=translator.get('available_commands'))
     
@@ -600,10 +608,11 @@ def create_parser() -> argparse.ArgumentParser:
     cfg_subparsers = config_parser.add_subparsers(dest='config_command')
     cfg_validate = cfg_subparsers.add_parser('validate', help='Validate dars.config.json in a project')
     cfg_validate.add_argument('--project', '-p', default='.', help='Project root (default: .)')
-    # Add language option to all subparsers
-    for subparser in [export_parser, info_parser, formats_parser, preview_parser, init_parser, build_parser, config_parser, cfg_validate]:
-        subparser.add_argument('--lang', '-l', choices=['en', 'es'], default='en',
-                              help=translator.get('lang_help'))
+
+    # Dev command (run entry in dev mode)
+    dev_parser = subparsers.add_parser('dev', help='Run the configured entry file in development mode')
+    dev_parser.add_argument('--project', '-p', default='.', help='Project root where dars.config.json resides (default: .)')
+    # English-only: no language option on subparsers
     
     return parser
 
@@ -725,42 +734,13 @@ def list_templates_detailed():
     console.print(table)
 def main():
     """Main CLI function"""
-    # Check for language parameter before parsing arguments
-    # If --lang is not specified, it will use the saved preference or default to English
-    for i, arg in enumerate(sys.argv):
-        if arg in ['--lang', '-l'] and i + 1 < len(sys.argv):
-            lang = sys.argv[i + 1]
-            if lang in ['en', 'es']:
-                # Save the language preference when explicitly specified
-                translator.set_language(lang, save=True)
+    # English-only: no language parameter pre-scan
     
-    # Intercept help before parsing arguments
+    # Intercept help before parsing arguments - print simple help without panels
     if len(sys.argv) == 1 or '-h' in sys.argv or '--help' in sys.argv:
         parser = create_parser()
-        
-        # Show banner
-        console.print(Panel(
-            Text("Dars Exporter", style="bold cyan", justify="center"),
-            subtitle=translator.get('main_description'),
-            border_style="cyan"
-        ))
-        
-        # If it's general help
-        if len(sys.argv) == 1 or (len(sys.argv) == 2 and (sys.argv[1] == '-h' or sys.argv[1] == '--help')):
-            RichHelpFormatter.rich_print_help(parser)
-            return
-        
-        # If it's help for a subcommand
-        if len(sys.argv) > 2 and (sys.argv[2] == '-h' or sys.argv[2] == '--help'):
-            subcommand = sys.argv[1]
-            # Get the corresponding subparser
-            subparsers_actions = [action for action in parser._actions 
-                                if isinstance(action, argparse._SubParsersAction)]
-            for subparsers_action in subparsers_actions:
-                for choice, subparser in subparsers_action.choices.items():
-                    if choice == subcommand:
-                        RichHelpFormatter.rich_print_help(subparser)
-                        return
+        parser.print_help()
+        return
     
     # Continue with normal flow if not help
     parser = create_parser()
@@ -775,12 +755,7 @@ def main():
         print_version_info()
         sys.exit(0)
 
-    # Show banner for normal commands
-    console.print(Panel(
-        Text("Dars Exporter", style="bold cyan", justify="center"),
-        subtitle=translator.get('cli_subtitle'),
-        border_style="cyan"
-    ))
+    # No banner for normal commands; keep output minimal
     
     exporter = DarsExporter()
     
@@ -825,6 +800,7 @@ def main():
             console.print(f"[red]{translator.get('error_output_create')}: {outdir} -> {e}[/red]")
             sys.exit(1)
 
+        ensure_dars_lib(project_root)
         success = exporter.export_app(app, args.format, outdir, args.preview)
         sys.exit(0 if success else 1)
         
@@ -849,6 +825,7 @@ def main():
             project_root = os.path.abspath(target_dir)
             os.makedirs(project_root, exist_ok=True)
             write_default_config(project_root, overwrite=False)
+            ensure_dars_lib(project_root)
             console.print("[green]✔ dars.config.json created/updated[/green]")
         elif not args.name:
             console.print("[red]Error: Project name is required[/red]")
@@ -885,6 +862,7 @@ def main():
             console.print(f"[red]{translator.get('error_output_create')}: {outdir} -> {e}[/red]")
             sys.exit(1)
 
+        ensure_dars_lib(project_root)
         app = exporter.load_app_from_file(entry)
         if app is None:
             sys.exit(1)
@@ -1013,9 +991,57 @@ def main():
                     RichHelpFormatter.rich_print_help(subparsers_action.choices['config'])
                     return
 
+    elif args.command == 'dev':
+        # Resolve project and config
+        project_root = os.path.abspath(getattr(args, 'project', '.'))
+        cfg, found = load_config(project_root)
+        if not found:
+            console.print("[yellow][Dars] Warning: dars.config.json not found. Run 'dars init --update' to create it.[/yellow]")
+        resolved = resolve_paths(cfg, project_root)
+        entry = resolved.get('entry_abs') or os.path.join(project_root, cfg.get('entry', 'main.py'))
+
+        if not os.path.exists(entry):
+            console.print(f"[red]{translator.get('error_entry_not_found_in_config')}: {entry}[/red]")
+            console.print(f"[yellow]{translator.get('edit_config_hint')}[/yellow]")
+            sys.exit(1)
+
+        # Ensure dars.min.js exists in project
+        ensure_dars_lib(project_root)
+        # Run entry in development mode (the entry typically calls app.rTimeCompile())
+        import subprocess
+        process = None
+        try:
+            console.print(f"[cyan]Running dev: {entry}[/cyan]")
+            process = subprocess.Popen([sys.executable, entry], cwd=os.path.dirname(entry))
+            process.wait()
+            sys.exit(process.returncode or 0)
+        except KeyboardInterrupt:
+            if process:
+                process.terminate()
+                process.wait()
+            sys.exit(0)
+        except Exception as e:
+            console.print(f"[red]Failed to start dev process: {e}[/red]")
+            sys.exit(1)
+
     else:
-        # Usar nuestro formateador personalizado en lugar del estándar
-        RichHelpFormatter.rich_print_help(parser)
+        # Fallback: print plain help
+        parser.print_help()
+
+# Utility: ensure lib/dars.min.js exists at project root (no overwrite)
+def ensure_dars_lib(project_root: str):
+    try:
+        os.makedirs(os.path.join(project_root, 'lib'), exist_ok=True)
+        dest = os.path.join(project_root, 'lib', 'dars.min.js')
+        if not os.path.exists(dest):
+            try:
+                from dars.js_lib import DARS_MIN_JS
+                with open(dest, 'w', encoding='utf-8') as fdst:
+                    fdst.write(DARS_MIN_JS)
+            except Exception:
+                pass
+    except Exception:
+        pass
 
 if __name__ == "__main__":
     main()

{dars_framework-1.1.8 → dars_framework-1.2.0}/dars/cli/preview.py

@@ -7,6 +7,7 @@ import os
 import sys
 import webbrowser
 import http.server
+import mimetypes
 import socketserver
 import threading
 import time
@@ -31,8 +32,11 @@ class PreviewServer:
             self.send_header('Access-Control-Allow-Origin', '*')
             super().end_headers()
         def guess_type(self, path):
-            if path.endswith('sw.js'):
+            # Ensure correct MIME types for JS modules and JSON
+            if path.endswith('.mjs') or path.endswith('.js'):
                 return 'application/javascript'
+            if path.endswith('.json'):
+                return 'application/json'
             return super().guess_type(path)
         def log_request(self, code='-', size='-'):
             """Silencia logs para peticiones frecuentes del hot-reload (version.txt)."""
@@ -58,6 +62,13 @@ class PreviewServer:
             os.chdir(self.directory)
             
             # Create the server
+            # Register mimetypes for strict module loading
+            try:
+                mimetypes.add_type('application/javascript', '.js')
+                mimetypes.add_type('application/javascript', '.mjs')
+                mimetypes.add_type('application/json', '.json')
+            except Exception:
+                pass
             handler = self.DarsRequestHandler
             self.server = socketserver.TCPServer(("", self.port), handler)