testeranto 0.203.0 → 0.205.0

package/src/components/pure/TestPageView_utils.tsx

@@ -1,287 +0,0 @@
-import React from "react";
-
-type TestData = {
-  name: string;
-  givens: {
-    name: string;
-    whens: {
-      name: string;
-      error?: string;
-      features?: string[];
-      artifacts?: string[];
-    }[];
-    thens: {
-      name: string;
-      error?: string;
-      features?: string[];
-      artifacts?: string[];
-    }[];
-    features?: string[];
-    artifacts?: string[];
-  }[];
-};
-
-// Determine language from file extension
-export const getLanguage = (path: string) => {
-  const ext = path.split(".").pop()?.toLowerCase();
-  switch (ext) {
-    case "ts":
-      return "typescript";
-    case "tsx":
-      return "typescript";
-    case "js":
-      return "javascript";
-    case "json":
-      return "json";
-    case "md":
-      return "markdown";
-    case "py":
-      return "python";
-    default:
-      return "plaintext";
-  }
-};
-
-export const renderTestResults = (
-  testData: TestData,
-  buildErrors,
-  projectName,
-  testName,
-  runtime
-) => {
-  return (
-    <div className="test-results">
-      {testData.givens.map((given, i) => (
-        <div key={i} className="mb-4 card">
-          <div className="card-header bg-primary text-white">
-            <div className="d-flex justify-content-between align-items-center">
-              <div>
-                <h4>Given: {given.name}</h4>
-                {given.features && given.features.length > 0 && (
-                  <div className="mt-1">
-                    <small>Features:</small>
-                    <ul className="list-unstyled">
-                      {given.features.map((feature, fi) => (
-                        <li key={fi}>
-                          {feature.startsWith("http") ? (
-                            <a
-                              href={feature}
-                              target="_blank"
-                              rel="noopener noreferrer"
-                              className="text-white"
-                            >
-                              {new URL(feature).hostname}
-                            </a>
-                          ) : (
-                            <span className="text-white">{feature}</span>
-                          )}
-                        </li>
-                      ))}
-                    </ul>
-                  </div>
-                )}
-              </div>
-              {given.artifacts && given.artifacts.length > 0 && (
-                <div className="dropdown">
-                  <button
-                    className="btn btn-sm btn-light dropdown-toggle"
-                    type="button"
-                    data-bs-toggle="dropdown"
-                  >
-                    Artifacts ({given.artifacts.length})
-                  </button>
-                  <ul className="dropdown-menu dropdown-menu-end">
-                    {given.artifacts.map((artifact, ai) => (
-                      <li key={ai}>
-                        <a
-                          className="dropdown-item"
-                          href={`reports/${projectName}/${testName
-                            .split(".")
-                            .slice(0, -1)
-                            .join(".")}/${runtime}/${artifact}`}
-                          target="_blank"
-                          rel="noopener noreferrer"
-                        >
-                          {artifact.split("/").pop()}
-                        </a>
-                      </li>
-                    ))}
-                  </ul>
-                </div>
-              )}
-            </div>
-          </div>
-          <div className="card-body">
-            {given.whens.map((when, j) => (
-              <div
-                key={`w-${j}`}
-                className={`p-3 mb-2 ${when.error ? "bg-danger text-white" : "bg-success text-white"
-                  }`}
-              >
-                <div className="d-flex justify-content-between align-items-start">
-                  <div>
-                    <div>
-                      <strong>When:</strong> {when.name}
-                      {when.features && when.features.length > 0 && (
-                        <div className="mt-2">
-                          <small>Features:</small>
-                          <ul className="list-unstyled">
-                            {when.features.map((feature, fi) => (
-                              <li key={fi}>
-                                {feature.startsWith("http") ? (
-                                  <a
-                                    href={feature}
-                                    target="_blank"
-                                    rel="noopener noreferrer"
-                                  >
-                                    {new URL(feature).hostname}
-                                  </a>
-                                ) : (
-                                  feature
-                                )}
-                              </li>
-                            ))}
-                          </ul>
-                        </div>
-                      )}
-                      {when.error && <pre className="mt-2">{when.error}</pre>}
-                    </div>
-                  </div>
-                  {when.artifacts && when.artifacts.length > 0 && (
-                    <div className="ms-3">
-                      <strong>Artifacts:</strong>
-                      <ul className="list-unstyled">
-                        {when.artifacts.map((artifact, ai) => (
-                          <li key={ai}>
-                            <a
-                              href={`reports/${projectName}/${testName
-                                .split(".")
-                                .slice(0, -1)
-                                .join(".")}/${runtime}/${artifact}`}
-                              target="_blank"
-                              className="text-white"
-                              rel="noopener noreferrer"
-                            >
-                              {artifact.split("/").pop()}
-                            </a>
-                          </li>
-                        ))}
-                      </ul>
-                    </div>
-                  )}
-                </div>
-              </div>
-            ))}
-            {given.thens.map((then, k) => (
-              <div
-                key={`t-${k}`}
-                className={`p-3 mb-2 ${then.error ? "bg-danger text-white" : "bg-success text-white"
-                  }`}
-              >
-                <div className="d-flex justify-content-between align-items-start">
-                  <div>
-                    <div>
-                      <strong>Then:</strong> {then.name}
-                      {then.features && then.features.length > 0 && (
-                        <div className="mt-2">
-                          <small>Features:</small>
-                          <ul className="list-unstyled">
-                            {then.features.map((feature, fi) => (
-                              <li key={fi}>
-                                {feature.startsWith("http") ? (
-                                  <a
-                                    href={feature}
-                                    target="_blank"
-                                    rel="noopener noreferrer"
-                                  >
-                                    {new URL(feature).hostname}
-                                  </a>
-                                ) : (
-                                  feature
-                                )}
-                              </li>
-                            ))}
-                          </ul>
-                        </div>
-                      )}
-                      {then.error && <pre className="mt-2">{then.error}</pre>}
-                    </div>
-                  </div>
-                  {then.artifacts && then.artifacts.length > 0 && (
-                    <div className="ms-3">
-                      <strong>Artifacts:</strong>
-                      <ul className="list-unstyled">
-                        {then.artifacts.map((artifact, ai) => (
-                          <li key={ai}>
-                            <a
-                              href={`reports/${projectName}/${testName
-                                .split(".")
-                                .slice(0, -1)
-                                .join(".")}/${runtime}/${artifact}`}
-                              target="_blank"
-                              className="text-white"
-                              rel="noopener noreferrer"
-                            >
-                              {artifact.split("/").pop()}
-                            </a>
-                          </li>
-                        ))}
-                      </ul>
-                    </div>
-                  )}
-                </div>
-              </div>
-            ))}
-          </div>
-        </div>
-      ))}
-      {/* Render build errors and warnings */}
-      {(buildErrors.errors.length > 0 || buildErrors.warnings.length > 0) && (
-        <div className="mb-4 card border-danger">
-          <div className="card-header bg-danger text-white">
-            <h4>Build Errors and Warnings</h4>
-          </div>
-          <div className="card-body">
-            {buildErrors.errors.length > 0 && (
-              <>
-                <h5>Errors</h5>
-                <ul>
-                  {buildErrors.errors.map((error, idx) => (
-                    <li key={`build-error-${idx}`}>
-                      <strong>{error.text}</strong>
-                      {error.location && (
-                        <div>
-                          File: {error.location.file} Line:{" "}
-                          {error.location.line} Column: {error.location.column}
-                        </div>
-                      )}
-                    </li>
-                  ))}
-                </ul>
-              </>
-            )}
-            {buildErrors.warnings.length > 0 && (
-              <>
-                <h5>Warnings</h5>
-                <ul>
-                  {buildErrors.warnings.map((warning, idx) => (
-                    <li key={`build-warning-${idx}`}>
-                      <strong>{warning.text}</strong>
-                      {warning.location && (
-                        <div>
-                          File: {warning.location.file} Line:{" "}
-                          {warning.location.line} Column:{" "}
-                          {warning.location.column}
-                        </div>
-                      )}
-                    </li>
-                  ))}
-                </ul>
-              </>
-            )}
-          </div>
-        </div>
-      )}
-    </div>
-  );
-};

package/src/components/stateful/FeaturesReporter.tsx

@@ -1,26 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import React, { useEffect, useState } from 'react';
-
-import { FeaturesReporterView } from '../pure/FeaturesReporterView';
-import { buildTree } from '../../types/features';
-
-export const FeaturesReporter: React.FC = () => {
-  const [treeData, setTreeData] = useState<any[]>([]);
-
-  useEffect(() => {
-    const fetchProjects = async () => {
-      try {
-        const response = await fetch('projects.json');
-        if (!response.ok) throw new Error('Failed to fetch projects');
-        const projectNames: string[] = await response.json();
-        setTreeData(buildTree(projectNames));
-      } catch (error) {
-        console.error('Error loading projects:', error);
-      }
-    };
-
-    fetchProjects();
-  }, []);
-
-  return <FeaturesReporterView treeData={treeData} />;
-};

package/src/components/stateful/GenericXMLEditor/AttributeEditor.tsx

@@ -1,87 +0,0 @@
-import React from 'react';
-import { Form } from 'react-bootstrap';
-import { XMLNode } from '../GenericXMLEditorPage';
-
-interface AttributeEditorProps {
-  selectedNode: XMLNode | null;
-  onUpdateNode: (nodeId: string, attributes: Record<string, string>) => void;
-}
-
-export const AttributeEditor: React.FC<AttributeEditorProps> = ({
-  selectedNode,
-  onUpdateNode
-}) => {
-  if (!selectedNode) {
-    return (
-      <div className="p-3 text-muted">
-        Select a node to edit its attributes
-      </div>
-    );
-  }
-
-  const handleAttributeChange = (key: string, value: string) => {
-    const newAttributes = { ...selectedNode.attributes };
-    if (value === '') {
-      delete newAttributes[key];
-    } else {
-      newAttributes[key] = value;
-    }
-    onUpdateNode(selectedNode.id, newAttributes);
-  };
-
-  const handleAddAttribute = () => {
-    const newKey = prompt('Enter attribute name:');
-    if (newKey && newKey.trim() !== '') {
-      const newAttributes = { ...selectedNode.attributes, [newKey]: '' };
-      onUpdateNode(selectedNode.id, newAttributes);
-    }
-  };
-
-  const handleRemoveAttribute = (key: string) => {
-    const newAttributes = { ...selectedNode.attributes };
-    delete newAttributes[key];
-    onUpdateNode(selectedNode.id, newAttributes);
-  };
-
-  return (
-    <div className="p-3">
-      <div className="d-flex justify-content-between align-items-center mb-3">
-        <h6>Attributes for {selectedNode.type}</h6>
-        <button
-          className="btn btn-sm btn-outline-success"
-          onClick={handleAddAttribute}
-        >
-          + Add
-        </button>
-      </div>
-      
-      {Object.entries(selectedNode.attributes).map(([key, value]) => (
-        <div key={key} className="mb-2 d-flex align-items-center">
-          <Form.Group className="flex-grow-1 me-2">
-            <Form.Label className="small mb-0">{key}</Form.Label>
-            <Form.Control
-              type="text"
-              size="sm"
-              value={value}
-              onChange={(e) => handleAttributeChange(key, e.target.value)}
-              placeholder="Value"
-            />
-          </Form.Group>
-          <button
-            className="btn btn-sm btn-outline-danger"
-            onClick={() => handleRemoveAttribute(key)}
-            style={{ marginTop: '1.5rem' }}
-          >
-            ×
-          </button>
-        </div>
-      ))}
-      
-      {Object.keys(selectedNode.attributes).length === 0 && (
-        <div className="text-muted small">
-          No attributes defined
-        </div>
-      )}
-    </div>
-  );
-};

package/src/components/stateful/GenericXMLEditor/GenericPreview.tsx

@@ -1,160 +0,0 @@
-import React, { useState, useRef, useCallback } from 'react';
-import { Button, ButtonGroup } from 'react-bootstrap';
-import { XMLNode } from '../GenericXMLEditorPage';
-
-interface GenericPreviewProps {
-  xmlTree: XMLNode;
-  selectedNodeId: string | null;
-  hiddenNodes: Set<string>;
-  renderPreview: (node: XMLNode, isSelected: boolean, eventHandlers: any) => React.ReactElement;
-}
-
-export const GenericPreview: React.FC<GenericPreviewProps> = ({
-  xmlTree,
-  selectedNodeId,
-  hiddenNodes,
-  renderPreview
-}) => {
-  const [scale, setScale] = useState(1);
-  const [position, setPosition] = useState({ x: 0, y: 0 });
-  const [isPanning, setIsPanning] = useState(false);
-  const [startPanPoint, setStartPanPoint] = useState({ x: 0, y: 0 });
-  const previewRef = useRef<HTMLDivElement>(null);
-
-  const renderNode = (node: XMLNode): React.ReactElement | null => {
-    // Skip rendering if node is hidden
-    if (hiddenNodes.has(node.id)) {
-      return null;
-    }
-    
-    const isSelected = selectedNodeId === node.id;
-    const eventHandlers = {};
-    
-    // Render children
-    const children = node.children
-      .map(renderNode)
-      .filter(child => child !== null) as React.ReactElement[];
-    
-    // Use the provided renderPreview function
-    return renderPreview(node, isSelected, eventHandlers);
-  };
-
-  // Handle mouse events for panning
-  const handleMouseDown = useCallback((e: React.MouseEvent) => {
-    if (e.button === 1 || (e.button === 0 && e.altKey)) { // Middle click or Alt + Left click
-      e.preventDefault();
-      setIsPanning(true);
-      setStartPanPoint({ x: e.clientX - position.x, y: e.clientY - position.y });
-    }
-  }, [position]);
-
-  const handleMouseMove = useCallback((e: React.MouseEvent) => {
-    if (isPanning) {
-      setPosition({
-        x: e.clientX - startPanPoint.x,
-        y: e.clientY - startPanPoint.y
-      });
-    }
-  }, [isPanning, startPanPoint]);
-
-  const handleMouseUp = useCallback(() => {
-    setIsPanning(false);
-  }, []);
-
-  const handleWheel = useCallback((e: React.WheelEvent) => {
-    e.preventDefault();
-    const delta = -e.deltaY * 0.01;
-    setScale(prevScale => Math.max(0.1, Math.min(5, prevScale + delta)));
-  }, []);
-
-  const resetView = useCallback(() => {
-    setScale(1);
-    setPosition({ x: 0, y: 0 });
-  }, []);
-
-  // Check if we're rendering SVG content (root node is svg)
-  const isSVG = xmlTree.type === 'svg';
-  
-  // For SVG, we need to handle the transform differently
-  if (isSVG) {
-    return (
-      <div 
-        className="border rounded p-3 d-flex justify-content-center align-items-center position-relative" 
-        style={{ height: '400px', overflow: 'hidden' }}
-        ref={previewRef}
-        onMouseDown={handleMouseDown}
-        onMouseMove={handleMouseMove}
-        onMouseUp={handleMouseUp}
-        onMouseLeave={handleMouseUp}
-        onWheel={handleWheel}
-      >
-        {/* Navigation controls */}
-        <div className="position-absolute top-0 end-0 m-2">
-          <ButtonGroup size="sm">
-            <Button variant="outline-secondary" onClick={() => setScale(s => Math.min(5, s + 0.1))}>
-              +
-            </Button>
-            <Button variant="outline-secondary" onClick={() => setScale(s => Math.max(0.1, s - 0.1))}>
-              -
-            </Button>
-            <Button variant="outline-secondary" onClick={resetView}>
-              Reset
-            </Button>
-          </ButtonGroup>
-        </div>
-        
-        {/* Panning cursor style */}
-        <div style={{ 
-          cursor: isPanning ? 'grabbing' : (scale !== 1 ? 'grab' : 'default'),
-          transform: `scale(${scale}) translate(${position.x}px, ${position.y}px)`,
-          transformOrigin: 'center center',
-          transition: isPanning ? 'none' : 'transform 0.1s ease'
-        }}>
-          <svg {...xmlTree.attributes} style={{ background: '#f8f9fa' }}>
-            {xmlTree.children.map(renderNode)}
-          </svg>
-        </div>
-      </div>
-    );
-  }
-  
-  // For non-SVG content (HTML/bootstrap), use a different approach
-  return (
-    <div 
-      className="border rounded p-3 position-relative" 
-      style={{ height: '400px', overflow: 'hidden' }}
-      ref={previewRef}
-      onMouseDown={handleMouseDown}
-      onMouseMove={handleMouseMove}
-      onMouseUp={handleMouseUp}
-      onMouseLeave={handleMouseUp}
-      onWheel={handleWheel}
-    >
-      {/* Navigation controls */}
-      <div className="position-absolute top-0 end-0 m-2">
-        <ButtonGroup size="sm">
-          <Button variant="outline-secondary" onClick={() => setScale(s => Math.min(5, s + 0.1))}>
-            +
-          </Button>
-          <Button variant="outline-secondary" onClick={() => setScale(s => Math.max(0.1, s - 0.1))}>
-            -
-          </Button>
-          <Button variant="outline-secondary" onClick={resetView}>
-            Reset
-          </Button>
-        </ButtonGroup>
-      </div>
-      
-      {/* Panning cursor style */}
-      <div style={{ 
-        cursor: isPanning ? 'grabbing' : (scale !== 1 ? 'grab' : 'default'),
-        transform: `scale(${scale}) translate(${position.x}px, ${position.y}px)`,
-        transformOrigin: '0 0',
-        transition: isPanning ? 'none' : 'transform 0.1s ease',
-        height: '100%'
-      }}>
-        {xmlTree.children.map(renderNode)}
-      </div>
-    </div>
-  );
-};

package/src/components/stateful/GenericXMLEditor/GenericTextEditor.tsx

@@ -1,104 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Form, Alert, Button } from 'react-bootstrap';
-import { XMLNode } from '../GenericXMLEditorPage';
-
-interface GenericTextEditorProps {
-  xmlTree: XMLNode;
-  onUpdateTree: (tree: XMLNode) => void;
-}
-
-const nodeToXML = (node: XMLNode, depth: number = 0): string => {
-  const indent = '  '.repeat(depth);
-  const attributes = Object.entries(node.attributes)
-    .map(([key, value]) => ` ${key}="${value}"`)
-    .join('');
-
-  if (node.children.length === 0) {
-    return `${indent}<${node.type}${attributes} />`;
-  } else {
-    const children = node.children.map(child => nodeToXML(child, depth + 1)).join('\n');
-    return `${indent}<${node.type}${attributes}>\n${children}\n${indent}</${node.type}>`;
-  }
-};
-
-export const GenericTextEditor: React.FC<GenericTextEditorProps> = ({
-  xmlTree,
-  onUpdateTree
-}) => {
-  const [xmlContent, setXmlContent] = useState('');
-  const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    try {
-      // For SVG, the root is the svg element itself, so we need to include its attributes
-      if (xmlTree.type === 'svg') {
-        const content = nodeToXML(xmlTree, 0);
-        setXmlContent(content);
-      } else {
-        // Convert the XML tree to XML, but only the children of the root
-        const content = xmlTree.children.map(child => nodeToXML(child, 0)).join('\n');
-        setXmlContent(content);
-      }
-      setError(null);
-    } catch (err) {
-      setError('Error generating XML');
-    }
-  }, [xmlTree]);
-
-  const handleXmlChange = (e: React.FormEvent<HTMLDivElement>) => {
-    const newContent = e.currentTarget.textContent || '';
-    setXmlContent(newContent);
-    setError(null);
-  };
-
-  const applyChanges = () => {
-    try {
-      // This is a placeholder - in a real implementation, you'd parse the XML
-      // and convert it back to an XMLNode structure
-      // For now, we'll just log an error
-      setError('XML parsing not implemented yet');
-    } catch (err) {
-      setError('Error parsing XML: ' + (err instanceof Error ? err.message : String(err)));
-    }
-  };
-
-  return (
-    <div className="h-100 d-flex flex-column align-items-center">
-      <div style={{ width: '80ch', maxWidth: '100%' }}>
-        <div 
-          contentEditable
-          onInput={handleXmlChange}
-          style={{ 
-            width: '80ch',
-            background: '#f8f9fa', 
-            padding: '1rem', 
-            borderRadius: '0.25rem',
-            overflow: 'auto',
-            minHeight: '400px',
-            fontFamily: 'monospace',
-            whiteSpace: 'pre-wrap',
-            wordBreak: 'break-word',
-            lineHeight: '1.4',
-            outline: 'none'
-          }}
-          suppressContentEditableWarning={true}
-        >
-          {xmlContent}
-        </div>
-        {error && (
-          <Alert variant="danger" className="mt-2">
-            {error}
-          </Alert>
-        )}
-        <Button
-          variant="primary"
-          onClick={applyChanges}
-          className="mt-2"
-          disabled={!!error}
-        >
-          Apply Changes
-        </Button>
-      </div>
-    </div>
-  );
-};