jac-client 0.1.0__py3-none-any.whl

jac_client/tests/test_cl.py

@@ -0,0 +1,360 @@
+"""Tests for Vite client bundle generation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import tempfile
+import subprocess
+
+from jaclang.runtimelib.machine import JacMachine as Jac
+from jaclang.utils.test import TestCase
+from jac_client.plugin.vite_client_bundle import ViteClientBundleBuilder
+
+
+class ViteClientBundleBuilderTests(TestCase):
+    """Validate Vite-powered client bundle compilation."""
+
+    def setUp(self) -> None:
+        Jac.reset_machine()
+        return super().setUp()
+
+    def tearDown(self) -> None:
+        Jac.reset_machine()
+        return super().tearDown()
+    
+    def _create_test_project_with_vite(self, temp_path: Path, include_antd: bool = False) -> tuple[Path, Path]:
+        """Create a minimal test project with Vite installed.
+        
+        Args:
+            temp_path: Path to the temporary directory
+            include_antd: If True, includes antd in dependencies
+        """
+        # Create package.json with base dependencies
+        dependencies = {
+            "react": "^18.0.0",
+            "react-dom": "^18.0.0"
+        }
+        
+        # Add antd if requested
+        if include_antd:
+            dependencies["antd"] = "^5.0.0"
+        
+        # Format dependencies for JSON
+        deps_str = ",\n".join(f'                "{k}": "{v}"' for k, v in dependencies.items())
+        
+        package_json = temp_path / "package.json"
+        package_json.write_text(f"""{{
+            "name": "test-client",
+            "version": "0.0.1",
+            "dependencies": {{
+{deps_str}
+            }},
+            "devDependencies": {{
+                "vite": "^5.0.0"
+            }}
+        }}""", encoding="utf-8")
+        
+        # Install dependencies
+        subprocess.run(
+            ["npm", "install"],
+            cwd=temp_path,
+            check=True,
+            capture_output=True,
+        )
+        
+        # Create output directory
+        output_dir = temp_path / "static" / "client" / "js"
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        temp_dir = temp_path / "temp"
+        temp_dir.mkdir(parents=True, exist_ok=True)
+        
+        return package_json, output_dir
+
+    def test_build_bundle_with_vite(self) -> None:
+        """Test that Vite bundling produces optimized output with proper structure."""
+        # Create a temporary directory for our test project
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            
+            # Create project with Vite installed
+            package_json, output_dir = self._create_test_project_with_vite(temp_path)
+            
+            # Initialize the Vite builder
+            builder = ViteClientBundleBuilder(
+                vite_package_json=package_json,
+                vite_output_dir=output_dir,
+                vite_minify=False,  # Disable minification for easier inspection
+            )
+            
+            # Import the test module
+            fixtures_dir = Path(__file__).parent / "fixtures"
+            (module,) = Jac.jac_import("client_app", str(fixtures_dir))
+            
+            # Build the bundle
+            bundle = builder.build(module, force=True)
+            
+            # Verify bundle structure
+            self.assertIsNotNone(bundle)
+            self.assertEqual(bundle.module_name, "client_app")
+            self.assertIn("client_page", bundle.client_functions)
+            self.assertIn("ButtonProps", bundle.client_functions)
+            self.assertIn("API_LABEL", bundle.client_globals)
+            self.assertGreater(len(bundle.hash), 10)
+            
+            # Verify bundle code contains expected content
+            self.assertIn("function client_page()", bundle.code)
+            self.assertIn('const API_LABEL = "Runtime Test";', bundle.code)
+            
+            # Verify the Jac initialization is present
+            self.assertIn("__jacRegisterClientModule", bundle.code)
+            self.assertIn("globalThis.start_app", bundle.code)
+            
+            # Verify bundle was written to output directory
+            bundle_files = list(output_dir.glob("client.*.js"))
+            self.assertGreater(len(bundle_files), 0, "Expected at least one bundle file")
+            
+            # Verify cached bundle is identical
+            cached = builder.build(module, force=False)
+            self.assertEqual(bundle.hash, cached.hash)
+            self.assertEqual(bundle.code, cached.code)
+
+    def test_vite_bundle_without_package_json(self) -> None:
+        """Test that missing package.json raises appropriate error."""
+        fixtures_dir = Path(__file__).parent / "fixtures"
+        (module,) = Jac.jac_import("client_app", str(fixtures_dir))
+        
+        # Create builder without package.json
+        builder = ViteClientBundleBuilder(
+            vite_package_json=Path("/nonexistent/package.json"),
+            vite_output_dir=Path("/tmp/output"),
+        )
+        
+        # Building should raise an error
+        from jaclang.runtimelib.client_bundle import ClientBundleError
+        with self.assertRaises(ClientBundleError) as cm:
+            builder.build(module, force=True)
+        
+        self.assertIn("Vite package.json not found", str(cm.exception))
+
+    def test_global_exposure_in_bundle(self) -> None:
+        """Test that client functions are properly exposed globally for Vite IIFE."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            
+            # Create project with Vite installed
+            package_json, output_dir = self._create_test_project_with_vite(temp_path)
+            
+            # Initialize the Vite builder
+            builder = ViteClientBundleBuilder(
+                vite_package_json=package_json,
+                vite_output_dir=output_dir,
+            )
+            
+            # Import the test module
+            fixtures_dir = Path(__file__).parent / "fixtures"
+            (module,) = Jac.jac_import("client_app", str(fixtures_dir))
+            
+            # Build the bundle
+            bundle = builder.build(module, force=True)
+            
+            # Verify global exposure code is present
+            # Note: Variable names may be minified, so we check for the concept rather than exact strings
+            self.assertIn("__jacEnsureHydration", bundle.code)
+            self.assertIn("globalThis.start_app()", bundle.code)
+            
+            # Cleanup
+            builder.cleanup_temp_dir()
+
+    def test_build_bundle_with_antd(self) -> None:
+        """Test that Vite bundling works with Ant Design components."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            
+            # Create project with Vite and Ant Design installed
+            package_json, output_dir = self._create_test_project_with_vite(temp_path, include_antd=True)
+            
+            # Initialize the Vite builder
+            builder = ViteClientBundleBuilder(
+                vite_package_json=package_json,
+                vite_output_dir=output_dir,
+                vite_minify=False,
+            )
+            
+            # Import the test module with Ant Design
+            fixtures_dir = Path(__file__).parent / "fixtures"
+            (module,) = Jac.jac_import("client_app_with_antd", str(fixtures_dir))
+            
+            # Build the bundle
+            bundle = builder.build(module, force=True)
+            
+            # Verify bundle structure
+            self.assertIsNotNone(bundle)
+            self.assertEqual(bundle.module_name, "client_app_with_antd")
+            self.assertIn("ButtonTest", bundle.client_functions)
+            self.assertIn("CardTest", bundle.client_functions)
+            self.assertIn("APP_NAME", bundle.client_globals)
+            
+            # Verify bundle code contains expected content
+            self.assertIn("function ButtonTest()", bundle.code)
+            self.assertIn("function CardTest()", bundle.code)
+            self.assertIn('const APP_NAME = "Ant Design Test";', bundle.code)
+            
+            # verify antd components are present
+            self.assertIn("ButtonGroup", bundle.code)
+
+            # Verify the Ant Design fixture content is present
+            self.assertIn("Testing Ant Design integration", bundle.code)
+            
+            # Verify bundle was written to output directory
+            bundle_files = list(output_dir.glob("client.*.js"))
+            self.assertGreater(len(bundle_files), 0, "Expected at least one bundle file")
+            
+            # Cleanup
+            builder.cleanup_temp_dir()
+
+    def test_relative_import(self) -> None:
+        """Test that relative imports work correctly in Vite bundling."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            
+            # Create project with Vite installed
+            package_json, output_dir = self._create_test_project_with_vite(temp_path, include_antd=True)
+            
+            # Initialize the Vite builder
+            builder = ViteClientBundleBuilder(
+                vite_package_json=package_json,
+                vite_output_dir=output_dir,
+                vite_minify=False,
+            )
+            
+            # Import the test module with relative import
+            fixtures_dir = Path(__file__).parent / "fixtures"
+            (module,) = Jac.jac_import("relative_import", str(fixtures_dir))
+            
+            # Build the bundle
+            bundle = builder.build(module, force=True)
+            
+            # Verify bundle structure
+            self.assertIsNotNone(bundle)
+            self.assertEqual(bundle.module_name, "relative_import")
+            self.assertIn("RelativeImport", bundle.client_functions)
+            self.assertIn("main", bundle.client_functions)
+            self.assertIn("CustomButton", bundle.code)
+            
+            # Verify bundle code contains expected content
+            self.assertIn("function RelativeImport()", bundle.code)
+            self.assertIn("function main()", bundle.code)
+            
+            # Verify that the relative import (Button from .button) is properly resolved
+            self.assertIn("ButtonGroup", bundle.code)
+            
+            # Verify the Jac initialization is present
+            self.assertIn("__jacRegisterClientModule", bundle.code)
+            
+            # Verify bundle was written to output directory
+            bundle_files = list(output_dir.glob("client.*.js"))
+            self.assertGreater(len(bundle_files), 0, "Expected at least one bundle file")
+            
+            # Cleanup
+            builder.cleanup_temp_dir()
+
+    def test_js_import(self) -> None:
+        """Test that JavaScript file imports work correctly in Vite bundling."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            # Create project with Vite installed
+            package_json, output_dir = self._create_test_project_with_vite(temp_path)
+            
+            # Initialize the Vite builder
+            builder = ViteClientBundleBuilder(
+                vite_package_json=package_json,
+                vite_output_dir=output_dir,
+                vite_minify=False,
+            )
+            
+            # Import the test module with JavaScript import
+            fixtures_dir = Path(__file__).parent / "fixtures"
+            (module,) = Jac.jac_import("js_import", str(fixtures_dir))
+            
+            # Build the bundle
+            bundle = builder.build(module, force=True)
+            
+            # Verify bundle structure
+            self.assertIsNotNone(bundle)
+            self.assertEqual(bundle.module_name, "js_import")
+            self.assertIn("JsImportTest", bundle.client_functions)
+            self.assertIn("Main", bundle.client_functions)
+            self.assertIn("JS_IMPORT_LABEL", bundle.client_globals)
+            
+            # Verify bundle code contains expected content
+            self.assertIn("function JsImportTest()", bundle.code)
+            self.assertIn("function Main()", bundle.code)
+            self.assertIn('const JS_IMPORT_LABEL = "JavaScript Import Test";', bundle.code)
+            
+            # Verify JavaScript imports are present in the bundle
+            # The JavaScript functions should be available in the bundle
+            self.assertIn("formatMessage", bundle.code)
+            self.assertIn("calculateSum", bundle.code)
+            self.assertIn("JS_CONSTANT", bundle.code)
+            self.assertIn("MessageFormatter", bundle.code)
+            
+            # Verify the JavaScript utility code is included
+            self.assertIn("Hello,", bundle.code)  # From formatMessage function
+            self.assertIn("Imported from JavaScript", bundle.code)  # From JS_CONSTANT
+            
+            # Verify the Jac initialization is present
+            self.assertIn("__jacRegisterClientModule", bundle.code)
+            
+            # Verify bundle was written to output directory
+            bundle_files = list(output_dir.glob("client.*.js"))
+            self.assertGreater(len(bundle_files), 0, "Expected at least one bundle file")
+            
+            # Cleanup
+            builder.cleanup_temp_dir()
+            
+    def test_jsx_fragments_and_spread_props(self) -> None:
+        """Test that JSX fragments and spread props work correctly."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            
+            # Create project with Vite installed
+            package_json, output_dir = self._create_test_project_with_vite(temp_path)
+            
+            # Initialize the Vite builder
+            builder = ViteClientBundleBuilder(
+                vite_package_json=package_json,
+                vite_output_dir=output_dir,
+                vite_minify=False,
+            )
+            
+            # Import the test module with fragments and spread props
+            fixtures_dir = Path(__file__).parent / "fixtures"
+            (module,) = Jac.jac_import("test_fragments_spread", str(fixtures_dir))
+            
+            # Build the bundle
+            bundle = builder.build(module, force=True)
+            
+            # Verify bundle structure
+            self.assertIsNotNone(bundle)
+            self.assertEqual(bundle.module_name, "test_fragments_spread")
+            self.assertIn("FragmentTest", bundle.client_functions)
+            self.assertIn("SpreadPropsTest", bundle.client_functions)
+            self.assertIn("MixedTest", bundle.client_functions)
+            self.assertIn("NestedFragments", bundle.client_functions)
+            
+            # Verify spread props handling (Object.assign is used by compiler)
+            self.assertIn("Object.assign", bundle.code)
+            
+            # Verify fragment test function exists
+            self.assertIn("function FragmentTest()", bundle.code)
+            
+            # Verify spread props test function exists
+            self.assertIn("function SpreadPropsTest()", bundle.code)
+            
+            # Verify bundle was written to output directory
+            bundle_files = list(output_dir.glob("client.*.js"))
+            self.assertGreater(len(bundle_files), 0, "Expected at least one bundle file")
+            
+            # Cleanup
+            builder.cleanup_temp_dir()

jac_client/tests/test_create_jac_app.py

@@ -0,0 +1,139 @@
+"""Test create-jac-app command."""
+
+import json
+import os
+import tempfile
+from subprocess import run
+from unittest import TestCase
+
+
+class TestCreateJacApp(TestCase):
+    """Test create-jac-app command functionality."""
+
+    def test_create_jac_app(self) -> None:
+        """Test create-jac-app command."""
+        test_project_name = "test-jac-app"
+        
+        # Create a temporary directory for testing
+        with tempfile.TemporaryDirectory() as temp_dir:
+            original_cwd = os.getcwd()
+            try:
+                # Change to temp directory
+                os.chdir(temp_dir)
+                
+                # Run create-jac-app command
+                result = run(
+                    [
+                        "jac",
+                        "create_jac_app",
+                        test_project_name
+                    ],
+                    capture_output=True,
+                    text=True,
+                    check=True
+                )
+                
+                # Check that command succeeded
+                self.assertEqual(result.returncode, 0)
+                self.assertIn(f"Successfully created Jac application '{test_project_name}'!", result.stdout)
+                
+                # Verify project directory was created
+                project_path = os.path.join(temp_dir, test_project_name)
+                self.assertTrue(os.path.exists(project_path))
+                self.assertTrue(os.path.isdir(project_path))
+                
+                # Verify package.json was created and has correct content
+                package_json_path = os.path.join(project_path, "package.json")
+                self.assertTrue(os.path.exists(package_json_path))
+                
+                with open(package_json_path, "r") as f:
+                    package_data = json.load(f)
+                
+                self.assertEqual(package_data["name"], test_project_name)
+                self.assertEqual(package_data["type"], "module")
+                self.assertIn("vite", package_data["devDependencies"])
+                self.assertIn("build", package_data["scripts"])
+                self.assertIn("dev", package_data["scripts"])
+                self.assertIn("preview", package_data["scripts"])
+                
+                # Verify app.jac file was created
+                app_jac_path = os.path.join(project_path, "app.jac")
+                self.assertTrue(os.path.exists(app_jac_path))
+                
+                with open(app_jac_path, "r") as f:
+                    app_jac_content = f.read()
+                
+                self.assertIn("jac_app()", app_jac_content)
+                
+                # Verify README.md was created
+                readme_path = os.path.join(project_path, "README.md")
+                self.assertTrue(os.path.exists(readme_path))
+                
+                with open(readme_path, "r") as f:
+                    readme_content = f.read()
+                
+                self.assertIn(f"# {test_project_name}", readme_content)
+                self.assertIn("jac serve app.jac", readme_content)
+                
+                # Verify node_modules was created (npm install ran)
+                node_modules_path = os.path.join(project_path, "node_modules")
+                self.assertTrue(os.path.exists(node_modules_path))
+                
+            finally:
+                # Return to original directory
+                os.chdir(original_cwd)
+
+    def test_create_jac_app_invalid_name(self) -> None:
+        """Test create-jac-app command with invalid project name."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(temp_dir)
+                
+                # Test with invalid name containing spaces
+                result = run(
+                    [
+                        "jac",
+                        "create_jac_app",
+                        "invalid name with spaces"
+                    ],
+                    capture_output=True,
+                    text=True
+                )
+                
+                # Should fail with non-zero exit code
+                self.assertNotEqual(result.returncode, 0)
+                self.assertIn("Project name must contain only letters, numbers, hyphens, and underscores", result.stderr)
+                
+            finally:
+                os.chdir(original_cwd)
+
+    def test_create_jac_app_existing_directory(self) -> None:
+        """Test create-jac-app command when directory already exists."""
+        test_project_name = "existing-test-app"
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(temp_dir)
+                
+                # Create the directory first
+                os.makedirs(test_project_name)
+                
+                # Try to create app with same name
+                result = run(
+                    [
+                        "jac",
+                        "create_jac_app",
+                        test_project_name
+                    ],
+                    capture_output=True,
+                    text=True
+                )
+                
+                # Should fail with non-zero exit code
+                self.assertNotEqual(result.returncode, 0)
+                self.assertIn(f"Directory '{test_project_name}' already exists", result.stderr)
+                
+            finally:
+                os.chdir(original_cwd)

jac_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: jac-client
+Version: 0.1.0
+Summary: 
+Author: Jason Mars
+Author-email: jason@mars.ninja
+Requires-Python: >=3.12.0,<4.0.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: jaclang (==0.8.10)
+Description-Content-Type: text/markdown
+
+# Jac Client
+
+Build full-stack web applications with Jac - one language for frontend and backend.
+
+Jac Client enables you to write React-like components, manage state, and build interactive UIs all in Jac. No need for separate frontend frameworks, HTTP clients, or complex build configurations.
+
+---
+
+## ✨ Features
+
+- **Single Language**: Write frontend and backend in Jac
+- **No HTTP Client**: Use `__jacSpawn()` instead of fetch/axios
+- **Reactive State**: Built-in state management with `createState()`
+- **Component-Based**: Build reusable UI components with JSX
+- **Graph Database**: Built-in graph data model eliminates need for SQL/NoSQL
+- **Type Safety**: Type checking across frontend and backend
+- **Vite-Powered**: Optimized production bundles with Vite
+
+---
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+pip install jac-client
+```
+
+### Create a New App
+
+```bash
+jac create_jac_app my-app
+cd my-app
+jac serve app.jac
+```
+
+Visit `http://localhost:8000` to see your app!
+
+---
+
+## 📚 Documentation
+
+For detailed guides and tutorials, see the **[docs folder](jac_client/docs/)**:
+
+- **[Getting Started Guide](jac_client/docs/README.md)** - Complete beginner's guide
+- **[Routing](jac_client/docs/routing.md)** - Multi-page applications with `initRouter()`
+- **[Lifecycle Hooks](jac_client/docs/lifecycle-hooks.md)** - Using `onMount()` for initialization
+- **[Advanced State](jac_client/docs/advanced-state.md)** - Managing complex state
+- **[Imports](jac_client/docs/imports.md)** - Importing libraries, Jac files, and JavaScript modules
+
+---
+
+## 💡 Example
+
+```jac
+cl {
+    let [count, setCount] = createState({"value": 0});
+
+    def Counter() -> any {
+        s = count();
+        return <div>
+            <h1>Count: {s.value}</h1>
+            <button onClick={lambda -> None {
+                setCount({"value": s.value + 1});
+            }}>
+                Increment
+            </button>
+        </div>;
+    }
+
+    def jac_app() -> any {
+        return Counter();
+    }
+}
+```
+
+---
+
+## 🔧 Requirements
+
+- Python: 3.12+
+- Node.js: For npm and Vite
+- Jac Language: `jaclang` (installed automatically)
+
+---
+
+## 🛠️ How It Works
+
+Jac Client is a plugin that:
+1. Compiles your `.jac` client code to JavaScript
+2. Bundles dependencies with Vite for optimal performance
+3. Provides a runtime for reactive state and components
+4. Integrates seamlessly with Jac's backend graph operations
+
+---
+
+## 📖 Learn More
+
+- **Full Documentation**: See [docs/](jac_client/docs/) for comprehensive guides
+- **Examples**: Check `jac_client/examples/` for working examples
+- **Issues**: Report bugs on [GitHub Issues](https://github.com/Jaseci-Labs/jaseci/issues)
+
+---
+
+## 📄 License
+
+MIT License - see [LICENSE](../LICENSE) file.
+
+---
+
+**Happy coding with Jac!** 🎉
+

jac_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+jac_client/docs/README.md,sha256=LM1d3OphsarGMmUtcdCFzu5eXkQTThofZuscfnmORzY,15435
+jac_client/docs/advanced-state.md,sha256=XpZwyXcFQNfcTdk5H9Cxcr-QhVWw8X9xcNIGpxXh13k,17107
+jac_client/docs/imports.md,sha256=hBIZLsIZoMMCajwRlvgGtjYk2WqVz9GkPqHlHonAnzE,12468
+jac_client/docs/lifecycle-hooks.md,sha256=Yg6Fuzgj5ouq0kA4KDU_x8-eFY95etyXP3ykAfoxkMk,12497
+jac_client/docs/routing.md,sha256=kIwJmy9UzuxkKpj8yuHWNYHceEZ1Zi8H_c6bRwXEG2M,13661
+jac_client/examples/little-x/app.jac,sha256=NueM8h35Bvf-hXL-kyeZ01-HAL7xZxUxrpHR99ASkhM,16760
+jac_client/examples/little-x/package-lock.json,sha256=wlaWHbdT4gt8g6EIZLkgRqLOuoX4DgquNIYCXk46M6g,99176
+jac_client/examples/little-x/package.json,sha256=XaXpijPuRDojT-yQFJwkaopDgqMiriepqEk0LsFQ-cU,521
+jac_client/examples/little-x/submit-button.jac,sha256=ByyRpDDN49RxoF8k7TC0r1mgoKAwwdlpo6wiiTE7p_4,324
+jac_client/examples/todo-app/README.md,sha256=eXQmqm63kuiNLF-FbHzE4oPQL26MiWu5_fvfc05X_iw,2101
+jac_client/examples/todo-app/app.jac,sha256=HQML_uFKFIY03EnSeat-xQKafnfzj1lQzu46m9QeWLs,25628
+jac_client/examples/todo-app/package-lock.json,sha256=56PSCXFx3qpwFpyyLf1sliNXobpvQPNfUDHYbOoRktE,31170
+jac_client/examples/todo-app/package.json,sha256=gGOWdeCfPAl6g8pjGVIuPUuEm8h1XUTjF1r6MeuXiN4,413
+jac_client/plugin/cli.py,sha256=4hB84MQ_3o2sWxWKIvmPURxnh_Kpt4iSrgoHHpFRRdA,10938
+jac_client/plugin/client.py,sha256=76fqmTcfHBOXGs2hcsb3Wq09L5GW0r-5-9JGdvU_Nhs,1277
+jac_client/plugin/client_runtime.jac,sha256=kjaODlNKjCbE-fXzkSYGN4k-SwmxsvBd4qQk9ZvYTGI,27507
+jac_client/plugin/vite_client_bundle.py,sha256=1sQwtd9VgLd3cutidRR9DJMiiKahBlWzhWilhXPwmtA,18074
+jac_client/tests/__init__.py,sha256=zleq_UtH4HBbp9SSkkqtaLd1tvm5F3QfXHEffXpxxQo,37
+jac_client/tests/fixtures/button.jac,sha256=8xLhhX7UpiRdzO9BLC1XwhejiKMEi50VlPFSjJP0XR8,109
+jac_client/tests/fixtures/client_app.jac,sha256=ReEvwsPHEh56RfSmW_KCM9sk6jjr5QnSENMUJHZfMVs,445
+jac_client/tests/fixtures/client_app_with_antd.jac,sha256=e-BK4TVlw8OKiCxIS0tH1-oJkWNEon-eMaJXvBvX39M,399
+jac_client/tests/fixtures/js_import.jac,sha256=GmAMLEFTp-CfoQ4G2JmFpD4boKpYh8JTC9LZRX5CieM,721
+jac_client/tests/fixtures/package-lock.json,sha256=RKNoyMoGXx3IOm3B5d1Kt0vrgMac9intCLXGew51AAQ,19358
+jac_client/tests/fixtures/package.json,sha256=s5Ltvbh1MQGeZZyyNJdqhoA21VO5F7scBcVPlgHpF3c,278
+jac_client/tests/fixtures/relative_import.jac,sha256=3ZDq-eg4BIdULklet-Enic-AVRFVnAbBkQwOOmfFbaM,190
+jac_client/tests/fixtures/test_fragments_spread.jac,sha256=z8Hs6N7HV8dE7jrW0NZtUt7Tbuo-bWkYBW4O8N7A-Rw,964
+jac_client/tests/fixtures/utils.js,sha256=lrcZ9yUEb4QrpUpUp0gWRvISFui9_v96rWPN-btllmU,413
+jac_client/tests/test_cl.py,sha256=4Ulr-5plEX3PDuVnIaMfFUcfQj3l0YrWd5ExNybpnIo,15398
+jac_client/tests/test_create_jac_app.py,sha256=UXDFYAjYHoRbNSfT0pfwVqXZ3h0cBMQ_nXevB0BpDtI,5518
+jac_client-0.1.0.dist-info/METADATA,sha256=mtXw8sK4Ac3Hc1IWp6bS9T9ImiW07l5Uk24UDZGWl1I,3202
+jac_client-0.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+jac_client-0.1.0.dist-info/entry_points.txt,sha256=WxzPDwDUGAvQyJ_RkIOSk3cJgJChESQGP839Kb70_vo,92
+jac_client-0.1.0.dist-info/RECORD,,

jac_client-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

jac_client-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[jac]
+create_jac_app=jac_client.plugin.cli:JacCmd
+serve=jac_client.plugin.client:JacClient
+