sdui-python 1.0.7__py3-none-any.whl

bin/component-cli.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+// Calculate the correct path to dist directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const distPath = join(__dirname, '..', 'dist', 'python-package.esm.js');
+const { getAvailableComponents, isValidComponentType, validateComponentStructure, getAllCommonProperties, getCategorizedCommonProperties, getAllThemes } = await import(distPath);
+
+// Handle JSON input from stdin
+async function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('readable', () => {
+      let chunk;
+      while ((chunk = process.stdin.read()) !== null) {
+        data += chunk;
+      }
+    });
+    process.stdin.on('end', () => {
+      resolve(data);
+    });
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  
+  try {
+    switch (command) {
+      case '--available':
+        // Return list of available components with their properties
+        const components = getAvailableComponents();
+        console.log(JSON.stringify(components));
+        break;
+        
+      case '--validate':
+        // Validate component type
+        const componentType = args[1] || '';
+        const isValid = isValidComponentType(componentType);
+        console.log(JSON.stringify({ isValid }));
+        break;
+        
+      case '--validate-structure':
+        // Validate component structure
+        const inputData = await readStdin();
+        if (!inputData.trim()) {
+          console.error('Component JSON is required');
+          process.exit(1);
+        }
+        const componentJson = JSON.parse(inputData);
+        const result = validateComponentStructure(componentJson);
+        console.log(JSON.stringify(result));
+        break;
+        
+      case '--common-properties':
+        // Return all common properties
+        const commonProperties = getAllCommonProperties();
+        console.log(JSON.stringify(commonProperties));
+        break;
+        
+      case '--categorized-common-properties':
+        // Return categorized common properties
+        const categorizedCommonProperties = getCategorizedCommonProperties();
+        console.log(JSON.stringify(categorizedCommonProperties));
+        break;
+
+      case '--themes':
+        // Return supported themes as key -> description
+        const themes = getAllThemes();
+        console.log(JSON.stringify(themes));
+        break;
+        
+      default:
+        console.log('Usage:');
+        console.log('  component-cli.js --available');
+        console.log('  component-cli.js --validate <componentType>');
+        console.log('  component-cli.js --validate-structure < component.json');
+        console.log('  component-cli.js --common-properties');
+        console.log('  component-cli.js --categorized-common-properties');
+        console.log('  component-cli.js --themes');
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(JSON.stringify({ error: error.message }));
+    process.exit(1);
+  }
+}
+
+main();

bin/serialize-cli.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+// Calculate the correct path to dist directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const distPath = join(__dirname, '..', 'dist', 'python-package.esm.js');
+const { SduiASTSerializer, validateComponentStructure } = await import(distPath);
+
+// Handle JSON input from stdin
+async function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('readable', () => {
+      let chunk;
+      while ((chunk = process.stdin.read()) !== null) {
+        data += chunk;
+      }
+    });
+    process.stdin.on('end', () => {
+      resolve(data);
+    });
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  
+  try {
+    switch (command) {
+      case '--source':
+        // Serialize from source code
+        const sourceData = await readStdin();
+        if (!sourceData.trim()) {
+          console.error('Source code is required');
+          process.exit(1);
+        }
+        const { component, errors } = SduiASTSerializer.serializeFromSourceWithErrorCollection(sourceData);
+        if (errors.length > 0) {
+          console.error(JSON.stringify({ error: errors.join('; ') }));
+          process.exit(1);
+        }
+        console.log(JSON.stringify(component));
+        break;
+        
+      case '--file':
+        // Serialize component file
+        const fileData = await readStdin();
+        if (!fileData.trim()) {
+          console.error('File source code is required');
+          process.exit(1);
+        }
+        const fileResult = SduiASTSerializer.serializeComponentFile(fileData);
+        console.log(JSON.stringify(fileResult));
+        break;
+        
+      case '--component':
+        // Serialize component JSON
+        const componentData = await readStdin();
+        if (!componentData.trim()) {
+          console.error('Component JSON is required');
+          process.exit(1);
+        }
+        const componentJson = JSON.parse(componentData);
+        // For component JSON, we can just return it as-is since it's already serialized
+        // But we'll validate it first to ensure it's a valid component structure
+        const validationResult = validateComponentStructure(componentJson);
+        if (!validationResult.isValid) {
+          throw new Error(`Invalid component structure: ${validationResult.errors.join(', ')}`);
+        }
+        console.log(JSON.stringify(componentJson));
+        break;
+        
+      default:
+        console.log('Usage:');
+        console.log('  serialize-cli.js --source < source-code');
+        console.log('  serialize-cli.js --file < file-source-code');
+        console.log('  serialize-cli.js --component < component-json');
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(JSON.stringify({ error: error.message }));
+    process.exit(1);
+  }
+}
+
+main();

bin/type-check-cli.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+// Calculate the correct path to dist directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const distPath = join(__dirname, '..', 'dist', 'python-package.esm.js');
+
+// Handle JSON input from stdin
+async function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('readable', () => {
+      let chunk;
+      while ((chunk = process.stdin.read()) !== null) {
+        data += chunk;
+      }
+    });
+    process.stdin.on('end', () => {
+      resolve(data);
+    });
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  
+  try {
+    // Import the module and initialize TypeChecker
+    const module = await import(distPath);
+    if (module.SduiTypeChecker && module.ComponentDefinitions) {
+      // Use registerComponentSchemas with the ComponentDefinitions from the module
+      module.SduiTypeChecker.registerComponentSchemas(module.ComponentDefinitions);
+    }
+    
+    const { SduiTypeChecker } = module;
+    
+    switch (command) {
+      case '--component':
+        // Validate component JSON
+        const componentData = await readStdin();
+        if (!componentData.trim()) {
+          console.error('Component JSON is required');
+          process.exit(1);
+        }
+        const componentJson = JSON.parse(componentData);
+        const componentResult = SduiTypeChecker.validateComponent(componentJson);
+        console.log(JSON.stringify(componentResult));
+        break;
+        
+      case '--code':
+        // Validate code string
+        const codeData = await readStdin();
+        if (!codeData.trim()) {
+          console.error('Code string is required');
+          process.exit(1);
+        }
+        const codeResult = SduiTypeChecker.validateCodeString(codeData);
+        console.log(JSON.stringify(codeResult));
+        break;
+        
+      case '--component-auto':
+        // Validate component with auto-detection
+        const autoComponentData = await readStdin();
+        if (!autoComponentData.trim()) {
+          console.error('Component JSON is required');
+          process.exit(1);
+        }
+        const autoComponentJson = JSON.parse(autoComponentData);
+        const autoResult = SduiTypeChecker.validateComponentWithAutoDetection(autoComponentJson);
+        console.log(JSON.stringify(autoResult));
+        break;
+        
+      case '--code-auto':
+        // Validate code string with auto-detection
+        const autoCodeData = await readStdin();
+        if (!autoCodeData.trim()) {
+          console.error('Code string is required');
+          process.exit(1);
+        }
+        const autoCodeResult = SduiTypeChecker.validateCodeStringWithAutoDetection(autoCodeData);
+        console.log(JSON.stringify(autoCodeResult));
+        break;
+        
+      default:
+        console.log('Usage:');
+        console.log('  type-check-cli.js --component < component.json');
+        console.log('  type-check-cli.js --code < code-string');
+        console.log('  type-check-cli.js --component-auto < component.json');
+        console.log('  type-check-cli.js --code-auto < code-string');
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(JSON.stringify({ error: error.message }));
+    process.exit(1);
+  }
+}
+
+main();

examples/basic_usage.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""
+Example usage script for the SDUI Python package
+"""
+
+import json
+from sdui_python import (
+    get_available_components,
+    validate_from_source,
+    serialize_from_source,
+    get_all_common_properties
+)
+
+def example_component_operations():
+    print("=== Component Operations Example ===")
+    
+    # Get available components
+    components = get_available_components()
+    print(f"Available components ({len(components)}):")
+    for component in components[:5]:  # Show first 5
+        print(f"  - {component}")
+    if len(components) > 5:
+        print(f"  ... and {len(components) - 5} more")
+    print()
+
+def example_component_validation():
+    print("=== Component Validation Example ===")
+    
+    # Validate component structure
+    valid_component = """
+function MyComponent() {
+    return <SduiText text="Hello World" />;
+}
+"""
+    
+    result = validate_from_source(valid_component)
+    print("Valid component structure validation:")
+    print(f"  Is valid: {result['isValid']}")
+    print(f"  Errors: {result['errors']}")
+    print()
+    
+    # Test with invalid component
+    invalid_component = """
+function MyComponent() {
+    return <SduiText />;
+}
+"""
+    
+    result = validate_from_source(invalid_component)
+    print("Invalid component structure validation:")
+    print(f"  Is valid: {result['isValid']}")
+    print(f"  Errors: {result['errors']}")
+    print()
+
+def example_serialization():
+    print("=== Serialization Example ===")
+    
+    # Serialize JSX source code with variant-driven styling
+    jsx_code = """
+function MyComponent() {
+    return (
+        <SduiVStack spacing={16}>
+            <SduiText text="Welcome" variant="h1" />
+            <SduiButton text="Get Started" variant="default" size="lg" />
+        </SduiVStack>
+    );
+}
+"""
+    
+    result = serialize_from_source(jsx_code)
+    if result:
+        print("Serialized component successfully:")
+        print(f"  Type: {result['type']}")
+        print(f"  Props: {result['props']}")
+        if 'children' in result and result['children']:
+            print(f"  Number of children: {len(result['children'])}")
+    else:
+        print("Failed to serialize component")
+    print()
+
+def example_common_properties():
+    print("=== Common Properties Example ===")
+    
+    # Get all common properties (now only 5 in variant-driven system)
+    common_properties = get_all_common_properties()
+    print(f"Common properties ({len(common_properties)}):")
+    for prop_name, prop_info in common_properties.items():
+        print(f"  - {prop_name}: {prop_info['description']}")
+    print()
+    
+    # Show variant-driven components
+    components = get_available_components()
+    print("=== Variant-Driven Components ===")
+    
+    # Find components with variants
+    variant_components = []
+    for component in components:
+        if 'variant' in str(component['props']):
+            variant_components.append(component)
+    
+    print(f"Components with variants ({len(variant_components)}):")
+    for component in variant_components[:5]:  # Show first 5
+        print(f"  - {component['name']}")
+        if 'variant' in component['props']:
+            print(f"    Variant options: {component['props']['variant']['enumValues']}")
+        if 'size' in component['props']:
+            print(f"    Size options: {component['props']['size']['enumValues']}")
+    print()
+
+if __name__ == "__main__":
+    print("SDUI Python Package Usage Example")
+    print("=" * 35)
+    print()
+    
+    try:
+        example_component_operations()
+        example_component_validation()
+        example_serialization()
+        example_common_properties()
+        
+        print("Example completed successfully!")
+    except Exception as e:
+        print(f"Example failed with error: {e}")
+        print("Make sure Node.js is installed and the package is properly set up.")

examples/variant_driven_examples.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""
+Variant-driven component examples for the SDUI Python package
+"""
+
+import json
+import subprocess
+from sdui_python import get_available_components
+
+def example_button_variants():
+    """Demonstrate different button variants"""
+    print("=== Button Variants Example ===")
+    
+    # Get button component info
+    components = get_available_components()
+    button = next(c for c in components if c['name'] == 'SduiButton')
+    
+    print("Button variants:")
+    if 'variant' in button['props']:
+        print(f"  Available variants: {button['props']['variant']['enumValues']}")
+    if 'size' in button['props']:
+        print(f"  Available sizes: {button['props']['size']['enumValues']}")
+    
+    # Create buttons with different variants
+    button_examples = [
+        {
+            "type": "SduiButton",
+            "props": {
+                "text": "Primary Action",
+                "variant": "default",
+                "size": "lg"
+            }
+        },
+        {
+            "type": "SduiButton",
+            "props": {
+                "text": "Secondary Action",
+                "variant": "outline",
+                "size": "sm"
+            }
+        },
+        {
+            "type": "SduiButton",
+            "props": {
+                "text": "Danger",
+                "variant": "destructive",
+                "size": "default"
+            }
+        },
+        {
+            "type": "SduiButton",
+            "props": {
+                "text": "Link",
+                "variant": "link",
+                "size": "default"
+            }
+        }
+    ]
+    
+    # Validate each button variant
+    for i, button in enumerate(button_examples, 1):
+        result = subprocess.run([
+            'node', 'bin/component-cli.js', '--validate-structure'
+        ], input=json.dumps(button), capture_output=True, text=True)
+        validation_result = json.loads(result.stdout)
+        print(f"  Button {i}: '{button['props']['text']}' with variant '{button['props']['variant']}' - Valid: {validation_result['isValid']}")
+    
+    print()
+
+def example_text_variants():
+    """Demonstrate different text variants"""
+    print("=== Text Variants Example ===")
+    
+    # Get text component info
+    components = get_available_components()
+    text = next(c for c in components if c['name'] == 'SduiText')
+    
+    print("Text variants:")
+    if 'variant' in text['props']:
+        print(f"  Available variants: {text['props']['variant']['enumValues']}")
+    
+    # Create text examples with different variants
+    text_examples = [
+        {
+            "type": "SduiText",
+            "props": {
+                "text": "Main Title",
+                "variant": "h1"
+            }
+        },
+        {
+            "type": "SduiText",
+            "props": {
+                "text": "Section Title",
+                "variant": "h2"
+            }
+        },
+        {
+            "type": "SduiText",
+            "props": {
+                "text": "Body text paragraph",
+                "variant": "p"
+            }
+        },
+        {
+            "type": "SduiText",
+            "props": {
+                "text": "Important quote",
+                "variant": "blockquote"
+            }
+        },
+        {
+            "type": "SduiText",
+            "props": {
+                "text": "code snippet",
+                "variant": "code"
+            }
+        }
+    ]
+    
+    # Validate each text variant
+    for i, text in enumerate(text_examples, 1):
+        result = subprocess.run([
+            'node', 'bin/component-cli.js', '--validate-structure'
+        ], input=json.dumps(text), capture_output=True, text=True)
+        validation_result = json.loads(result.stdout)
+        print(f"  Text {i}: '{text['props']['text']}' with variant '{text['props']['variant']}' - Valid: {validation_result['isValid']}")
+    
+    print()
+
+def example_new_components():
+    """Demonstrate new components added in variant-driven system"""
+    print("=== New Components Example ===")
+    
+    # SduiFloatingButton example
+    floating_button = {
+        "type": "SduiFloatingButton",
+        "props": {
+            "icon": "plus",
+            "variant": "default",
+            "size": "lg",
+            "floatingVariant": "bottomRight"
+        }
+    }
+    
+    # SduiGrid example
+    grid_component = {
+        "type": "SduiGrid",
+        "props": {
+            "variant": "default",
+            "columnCount": 3,
+            "minimumItemWidth": 200
+        }
+    }
+    
+    # Validate new components
+    new_components = [
+        ("SduiFloatingButton", floating_button),
+        ("SduiGrid", grid_component)
+    ]
+    
+    for name, component in new_components:
+        result = subprocess.run([
+            'node', 'bin/component-cli.js', '--validate-structure'
+        ], input=json.dumps(component), capture_output=True, text=True)
+        validation_result = json.loads(result.stdout)
+        print(f"  {name}: {'Valid' if validation_result['isValid'] else 'Invalid'}")
+        if not validation_result['isValid']:
+            print(f"    Errors: {validation_result['errors']}")
+    
+    print()
+
+def example_complex_variant_structure():
+    """Demonstrate complex component structure with variants"""
+    print("=== Complex Variant Structure Example ===")
+    
+    complex_component = {
+        "type": "SduiVStack",
+        "props": {
+            "spacing": 20
+        },
+        "children": [
+            {
+                "type": "SduiText",
+                "props": {
+                    "text": "Welcome to SDUI",
+                    "variant": "h1"
+                }
+            },
+            {
+                "type": "SduiHStack",
+                "props": {
+                    "spacing": 12
+                },
+                "children": [
+                    {
+                        "type": "SduiButton",
+                        "props": {
+                            "text": "Save",
+                            "variant": "default",
+                            "size": "lg"
+                        }
+                    },
+                    {
+                        "type": "SduiButton",
+                        "props": {
+                            "text": "Cancel",
+                            "variant": "outline",
+                            "size": "lg"
+                        }
+                    }
+                ]
+            },
+            {
+                "type": "SduiCard",
+                "props": {
+                    "variant": "elevated"
+                },
+                "children": [
+                    {
+                        "type": "SduiText",
+                        "props": {
+                            "text": "Card content",
+                            "variant": "p"
+                        }
+                    }
+                ]
+            }
+        ]
+    }
+    
+    # Validate complex structure
+    result = subprocess.run([
+        'node', 'bin/component-cli.js', '--validate-structure'
+    ], input=json.dumps(complex_component), capture_output=True, text=True)
+    validation_result = json.loads(result.stdout)
+    print(f"Complex structure validation: {'Valid' if validation_result['isValid'] else 'Invalid'}")
+    if validation_result['isValid']:
+        print("  Root component: SduiVStack")
+        print("  Children: 3 (SduiText, SduiHStack, SduiCard)")
+    else:
+        print(f"  Errors: {validation_result['errors']}")
+    
+    print()
+
+if __name__ == "__main__":
+    print("Variant-Driven Component Examples")
+    print("=" * 35)
+    print()
+    
+    try:
+        example_button_variants()
+        example_text_variants()
+        example_new_components()
+        example_complex_variant_structure()
+        
+        print("All examples completed successfully!")
+    except Exception as e:
+        print(f"Example failed with error: {e}")
+        print("Make sure Node.js is installed and the package is properly set up.")