@specverse/engines 4.1.5 → 4.1.6

package/dist/libs/instance-factories/views/templates/shared/pattern-validator.js

@@ -0,0 +1,210 @@
+import { ATOMIC_COMPONENTS_REGISTRY } from "./atomic-components-registry.js";
+function validatePattern(pattern) {
+  const errors = [];
+  const warnings = [];
+  if (!pattern.id || pattern.id.trim() === "") {
+    errors.push({
+      field: "id",
+      message: "Pattern ID is required",
+      severity: "error"
+    });
+  }
+  if (!pattern.name || pattern.name.trim() === "") {
+    errors.push({
+      field: "name",
+      message: "Pattern name is required",
+      severity: "error"
+    });
+  }
+  if (!pattern.version || !isValidVersion(pattern.version)) {
+    errors.push({
+      field: "version",
+      message: "Pattern version must be in semver format (e.g., 1.0.0)",
+      severity: "error"
+    });
+  }
+  if (!pattern.description || pattern.description.trim() === "") {
+    warnings.push({
+      field: "description",
+      message: "Pattern description is recommended for clarity"
+    });
+  }
+  const validCategories = ["data-entry", "data-display", "dashboard", "navigation", "workflow"];
+  if (!validCategories.includes(pattern.category)) {
+    errors.push({
+      field: "category",
+      message: `Category must be one of: ${validCategories.join(", ")}`,
+      severity: "error"
+    });
+  }
+  if (!pattern.requiredAtomicComponents || pattern.requiredAtomicComponents.length === 0) {
+    errors.push({
+      field: "requiredAtomicComponents",
+      message: "At least one required atomic component must be specified",
+      severity: "error"
+    });
+  } else {
+    for (const component of pattern.requiredAtomicComponents) {
+      if (!ATOMIC_COMPONENTS_REGISTRY[component]) {
+        errors.push({
+          field: "requiredAtomicComponents",
+          message: `Required component '${component}' not found in ATOMIC_COMPONENTS_REGISTRY`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  if (pattern.optionalAtomicComponents) {
+    for (const component of pattern.optionalAtomicComponents) {
+      if (!ATOMIC_COMPONENTS_REGISTRY[component]) {
+        warnings.push({
+          field: "optionalAtomicComponents",
+          message: `Optional component '${component}' not found in ATOMIC_COMPONENTS_REGISTRY`
+        });
+      }
+    }
+  }
+  if (!pattern.layoutStrategy) {
+    errors.push({
+      field: "layoutStrategy",
+      message: "Layout strategy is required",
+      severity: "error"
+    });
+  } else {
+    const validLayoutTypes = ["single-column", "two-column", "grid", "flex", "masonry", "custom"];
+    if (!validLayoutTypes.includes(pattern.layoutStrategy.type)) {
+      errors.push({
+        field: "layoutStrategy.type",
+        message: `Layout type must be one of: ${validLayoutTypes.join(", ")}`,
+        severity: "error"
+      });
+    }
+  }
+  if (!pattern.dataBindings) {
+    errors.push({
+      field: "dataBindings",
+      message: "Data bindings are required",
+      severity: "error"
+    });
+  } else {
+    const validSources = ["model", "controller", "service", "store", "computed"];
+    if (!validSources.includes(pattern.dataBindings.source)) {
+      errors.push({
+        field: "dataBindings.source",
+        message: `Data source must be one of: ${validSources.join(", ")}`,
+        severity: "error"
+      });
+    }
+    if (!pattern.dataBindings.operations || pattern.dataBindings.operations.length === 0) {
+      errors.push({
+        field: "dataBindings.operations",
+        message: "At least one data operation must be specified",
+        severity: "error"
+      });
+    } else {
+      for (const op of pattern.dataBindings.operations) {
+        const validOps = ["create", "update", "retrieve", "retrieve_many", "validate", "evolve", "delete"];
+        if (!validOps.includes(op.operation)) {
+          errors.push({
+            field: "dataBindings.operations",
+            message: `Operation '${op.operation}' must be one of: ${validOps.join(", ")}`,
+            severity: "error"
+          });
+        }
+      }
+    }
+  }
+  if (!pattern.supportedOperations || pattern.supportedOperations.length === 0) {
+    errors.push({
+      field: "supportedOperations",
+      message: "At least one supported operation must be specified",
+      severity: "error"
+    });
+  }
+  if (pattern.eventHandlers) {
+    for (const handler of pattern.eventHandlers) {
+      if (!handler.event) {
+        errors.push({
+          field: "eventHandlers",
+          message: "Event handler must specify an event name",
+          severity: "error"
+        });
+      }
+      if (!handler.operation && !handler.handler) {
+        errors.push({
+          field: "eventHandlers",
+          message: `Event handler for '${handler.event}' must specify either operation or handler`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  if (pattern.dataBindings?.relationships) {
+    for (const rel of pattern.dataBindings.relationships) {
+      const validRelTypes = ["belongsTo", "hasMany", "hasOne", "manyToMany"];
+      if (!validRelTypes.includes(rel.type)) {
+        errors.push({
+          field: "dataBindings.relationships",
+          message: `Relationship type '${rel.type}' must be one of: ${validRelTypes.join(", ")}`,
+          severity: "error"
+        });
+      }
+      if (!rel.display?.labelField) {
+        warnings.push({
+          field: "dataBindings.relationships",
+          message: `Relationship '${rel.name}' should specify a labelField for display`
+        });
+      }
+    }
+  }
+  if (pattern.extends) {
+    warnings.push({
+      field: "extends",
+      message: `Pattern extends '${pattern.extends}' - ensure parent pattern exists`
+    });
+  }
+  if (pattern.customization) {
+    if (pattern.customization.requiredOverrides && pattern.customization.requiredOverrides.length > 0) {
+      const validFields = ["layoutStrategy", "sections", "operations", "relationships"];
+      for (const override of pattern.customization.requiredOverrides) {
+        if (!validFields.includes(override)) {
+          warnings.push({
+            field: "customization.requiredOverrides",
+            message: `Override field '${override}' may not be a valid customization point`
+          });
+        }
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function isValidVersion(version) {
+  const semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
+  return semverRegex.test(version);
+}
+function validatePatternRegistry(registry) {
+  const results = {};
+  for (const [id, pattern] of Object.entries(registry)) {
+    results[id] = validatePattern(pattern);
+  }
+  return results;
+}
+function getValidationSummary(results) {
+  const total = Object.keys(results).length;
+  const valid = Object.values(results).filter((r) => r.valid).length;
+  const invalid = total - valid;
+  const warnings = Object.values(results).reduce(
+    (sum, r) => sum + r.warnings.length,
+    0
+  );
+  return { total, valid, invalid, warnings };
+}
+export {
+  getValidationSummary,
+  validatePattern,
+  validatePatternRegistry
+};

package/dist/libs/instance-factories/views/templates/shared/property-mapper.js

@@ -0,0 +1,492 @@
+const FRAMEWORK_TARGETS = {
+  react: ["shadcn", "mui", "antd"],
+  vue: ["vuetify", "elementPlus", "primeVue"],
+  svelte: ["carbon", "svelteui"],
+  angular: ["angularMaterial", "primeNg"],
+  runtime: ["runtime"]
+};
+const VARIANT_MAPPING = {
+  primary: {
+    shadcn: "default",
+    mui: "contained",
+    antd: "primary",
+    vuetify: "primary",
+    elementPlus: "primary",
+    primeVue: "primary",
+    carbon: "primary",
+    svelteui: "primary",
+    angularMaterial: "primary",
+    primeNg: "primary",
+    runtime: "primary",
+    semantic: "primary-action"
+  },
+  secondary: {
+    shadcn: "secondary",
+    mui: "outlined",
+    antd: "default",
+    vuetify: "secondary",
+    elementPlus: "default",
+    primeVue: "secondary",
+    carbon: "secondary",
+    svelteui: "secondary",
+    angularMaterial: "accent",
+    primeNg: "secondary",
+    runtime: "secondary",
+    semantic: "secondary-action"
+  },
+  destructive: {
+    shadcn: "destructive",
+    mui: "error",
+    antd: "danger",
+    vuetify: "error",
+    elementPlus: "danger",
+    primeVue: "danger",
+    carbon: "danger",
+    svelteui: "error",
+    angularMaterial: "warn",
+    primeNg: "danger",
+    runtime: "destructive",
+    semantic: "destructive-action"
+  },
+  ghost: {
+    shadcn: "ghost",
+    mui: "text",
+    antd: "link",
+    vuetify: "text",
+    elementPlus: "text",
+    primeVue: "text",
+    carbon: "ghost",
+    svelteui: "ghost",
+    angularMaterial: "basic",
+    primeNg: "text",
+    runtime: "ghost",
+    semantic: "minimal-action"
+  },
+  outline: {
+    shadcn: "outline",
+    mui: "outlined",
+    antd: "default",
+    vuetify: "outlined",
+    elementPlus: "plain",
+    primeVue: "outlined",
+    carbon: "tertiary",
+    svelteui: "outline",
+    angularMaterial: "stroked",
+    primeNg: "outlined",
+    runtime: "outline",
+    semantic: "outlined-action"
+  }
+};
+const SIZE_MAPPING = {
+  small: {
+    shadcn: "sm",
+    mui: "small",
+    antd: "small",
+    vuetify: "small",
+    elementPlus: "small",
+    primeVue: "small",
+    carbon: "sm",
+    svelteui: "sm",
+    angularMaterial: "small",
+    primeNg: "small",
+    runtime: "small",
+    semantic: "compact"
+  },
+  medium: {
+    shadcn: "default",
+    mui: "medium",
+    antd: "middle",
+    vuetify: "default",
+    elementPlus: "default",
+    primeVue: "default",
+    carbon: "md",
+    svelteui: "md",
+    angularMaterial: "medium",
+    primeNg: "medium",
+    runtime: "medium",
+    semantic: "standard"
+  },
+  large: {
+    shadcn: "lg",
+    mui: "large",
+    antd: "large",
+    vuetify: "large",
+    elementPlus: "large",
+    primeVue: "large",
+    carbon: "lg",
+    svelteui: "lg",
+    angularMaterial: "large",
+    primeNg: "large",
+    runtime: "large",
+    semantic: "spacious"
+  }
+};
+const COLOR_MAPPING = {
+  primary: {
+    shadcn: "primary",
+    mui: "primary",
+    antd: "primary",
+    vuetify: "primary",
+    elementPlus: "primary",
+    primeVue: "primary",
+    carbon: "blue",
+    svelteui: "primary",
+    angularMaterial: "primary",
+    primeNg: "primary",
+    runtime: "primary",
+    semantic: "primary-color"
+  },
+  success: {
+    shadcn: "success",
+    mui: "success",
+    antd: "success",
+    vuetify: "success",
+    elementPlus: "success",
+    primeVue: "success",
+    carbon: "green",
+    svelteui: "success",
+    angularMaterial: "success",
+    primeNg: "success",
+    runtime: "success",
+    semantic: "positive-feedback"
+  },
+  warning: {
+    shadcn: "warning",
+    mui: "warning",
+    antd: "warning",
+    vuetify: "warning",
+    elementPlus: "warning",
+    primeVue: "warning",
+    carbon: "yellow",
+    svelteui: "warning",
+    angularMaterial: "warn",
+    primeNg: "warning",
+    runtime: "warning",
+    semantic: "caution-feedback"
+  },
+  error: {
+    shadcn: "destructive",
+    mui: "error",
+    antd: "error",
+    vuetify: "error",
+    elementPlus: "error",
+    primeVue: "danger",
+    carbon: "red",
+    svelteui: "error",
+    angularMaterial: "warn",
+    primeNg: "danger",
+    runtime: "error",
+    semantic: "negative-feedback"
+  },
+  info: {
+    shadcn: "default",
+    mui: "info",
+    antd: "info",
+    vuetify: "info",
+    elementPlus: "info",
+    primeVue: "info",
+    carbon: "cyan",
+    svelteui: "info",
+    angularMaterial: "primary",
+    primeNg: "info",
+    runtime: "info",
+    semantic: "informational-feedback"
+  }
+};
+const POSITION_MAPPING = {
+  top: {
+    shadcn: "top",
+    mui: "top",
+    antd: "top",
+    vuetify: "top",
+    elementPlus: "top",
+    primeVue: "top",
+    carbon: "top",
+    svelteui: "top",
+    angularMaterial: "above",
+    primeNg: "top",
+    runtime: "top",
+    semantic: "top-position"
+  },
+  bottom: {
+    shadcn: "bottom",
+    mui: "bottom",
+    antd: "bottom",
+    vuetify: "bottom",
+    elementPlus: "bottom",
+    primeVue: "bottom",
+    carbon: "bottom",
+    svelteui: "bottom",
+    angularMaterial: "below",
+    primeNg: "bottom",
+    runtime: "bottom",
+    semantic: "bottom-position"
+  },
+  left: {
+    shadcn: "left",
+    mui: "left",
+    antd: "left",
+    vuetify: "left",
+    elementPlus: "left",
+    primeVue: "left",
+    carbon: "left",
+    svelteui: "left",
+    angularMaterial: "before",
+    primeNg: "left",
+    runtime: "left",
+    semantic: "left-position"
+  },
+  right: {
+    shadcn: "right",
+    mui: "right",
+    antd: "right",
+    vuetify: "right",
+    elementPlus: "right",
+    primeVue: "right",
+    carbon: "right",
+    svelteui: "right",
+    angularMaterial: "after",
+    primeNg: "right",
+    runtime: "right",
+    semantic: "right-position"
+  }
+};
+const ORIENTATION_MAPPING = {
+  horizontal: {
+    shadcn: "horizontal",
+    mui: "horizontal",
+    antd: "horizontal",
+    vuetify: "horizontal",
+    elementPlus: "horizontal",
+    primeVue: "horizontal",
+    carbon: "horizontal",
+    svelteui: "horizontal",
+    angularMaterial: "horizontal",
+    primeNg: "horizontal",
+    runtime: "horizontal",
+    semantic: "horizontal-layout"
+  },
+  vertical: {
+    shadcn: "vertical",
+    mui: "vertical",
+    antd: "vertical",
+    vuetify: "vertical",
+    elementPlus: "vertical",
+    primeVue: "vertical",
+    carbon: "vertical",
+    svelteui: "vertical",
+    angularMaterial: "vertical",
+    primeNg: "vertical",
+    runtime: "vertical",
+    semantic: "vertical-layout"
+  }
+};
+const COMMON_PROPERTY_MAPPINGS = {
+  variant: VARIANT_MAPPING,
+  size: SIZE_MAPPING,
+  color: COLOR_MAPPING,
+  position: POSITION_MAPPING,
+  orientation: ORIENTATION_MAPPING
+};
+const COMPONENT_SPECIFIC_MAPPINGS = {
+  table: {
+    size: {
+      small: {
+        shadcn: "sm",
+        mui: "small",
+        antd: "small",
+        vuetify: "small",
+        elementPlus: "small",
+        primeVue: "small",
+        carbon: "sm",
+        svelteui: "compact",
+        angularMaterial: "small",
+        primeNg: "small",
+        runtime: "small",
+        semantic: "compact-table"
+      },
+      medium: {
+        shadcn: "default",
+        mui: "medium",
+        antd: "middle",
+        vuetify: "default",
+        elementPlus: "default",
+        primeVue: "default",
+        carbon: "md",
+        svelteui: "default",
+        angularMaterial: "medium",
+        primeNg: "medium",
+        runtime: "medium",
+        semantic: "standard-table"
+      },
+      large: {
+        shadcn: "lg",
+        mui: "large",
+        antd: "large",
+        vuetify: "large",
+        elementPlus: "large",
+        primeVue: "large",
+        carbon: "lg",
+        svelteui: "relaxed",
+        angularMaterial: "large",
+        primeNg: "large",
+        runtime: "large",
+        semantic: "spacious-table"
+      }
+    }
+  },
+  input: {
+    variant: {
+      // Inputs use different variant semantics
+      filled: {
+        shadcn: "default",
+        mui: "filled",
+        antd: "filled",
+        vuetify: "filled",
+        elementPlus: "default",
+        primeVue: "filled",
+        carbon: "default",
+        svelteui: "filled",
+        angularMaterial: "fill",
+        primeNg: "filled",
+        runtime: "filled",
+        semantic: "filled-input"
+      },
+      outlined: {
+        shadcn: "outline",
+        mui: "outlined",
+        antd: "outlined",
+        vuetify: "outlined",
+        elementPlus: "default",
+        primeVue: "outlined",
+        carbon: "outline",
+        svelteui: "outlined",
+        angularMaterial: "outline",
+        primeNg: "outlined",
+        runtime: "outlined",
+        semantic: "outlined-input"
+      },
+      standard: {
+        shadcn: "default",
+        mui: "standard",
+        antd: "borderless",
+        vuetify: "underlined",
+        elementPlus: "default",
+        primeVue: "standard",
+        carbon: "default",
+        svelteui: "standard",
+        angularMaterial: "standard",
+        primeNg: "standard",
+        runtime: "standard",
+        semantic: "standard-input"
+      }
+    }
+  },
+  badge: {
+    variant: {
+      // Badges use different variant semantics
+      dot: {
+        shadcn: "default",
+        mui: "dot",
+        antd: "default",
+        vuetify: "dot",
+        elementPlus: "default",
+        primeVue: "default",
+        carbon: "default",
+        svelteui: "dot",
+        angularMaterial: "default",
+        primeNg: "default",
+        runtime: "dot",
+        semantic: "notification-indicator"
+      },
+      standard: {
+        shadcn: "default",
+        mui: "standard",
+        antd: "default",
+        vuetify: "default",
+        elementPlus: "default",
+        primeVue: "default",
+        carbon: "default",
+        svelteui: "default",
+        angularMaterial: "default",
+        primeNg: "default",
+        runtime: "standard",
+        semantic: "count-indicator"
+      }
+    }
+  }
+};
+function mapProperty(componentType, propertyName, specverseValue, target) {
+  if (typeof specverseValue !== "string") {
+    return specverseValue;
+  }
+  const componentMapping = COMPONENT_SPECIFIC_MAPPINGS[componentType]?.[propertyName]?.[specverseValue];
+  if (componentMapping && target in componentMapping) {
+    return componentMapping[target];
+  }
+  const commonMapping = COMMON_PROPERTY_MAPPINGS[propertyName]?.[specverseValue];
+  if (commonMapping && target in commonMapping) {
+    return commonMapping[target];
+  }
+  return specverseValue;
+}
+function getSemanticMeaning(propertyName, specverseValue) {
+  const commonMapping = COMMON_PROPERTY_MAPPINGS[propertyName]?.[specverseValue];
+  if (commonMapping && "semantic" in commonMapping) {
+    return commonMapping.semantic;
+  }
+  return `${propertyName}-${specverseValue}`;
+}
+function mapProperties(componentType, properties, target) {
+  const mappedProperties = {};
+  for (const [propName, propValue] of Object.entries(properties)) {
+    mappedProperties[propName] = mapProperty(
+      componentType,
+      propName,
+      propValue,
+      target
+    );
+  }
+  return mappedProperties;
+}
+function getFrameworkTargets(category) {
+  return FRAMEWORK_TARGETS[category];
+}
+function hasMapping(componentType, propertyName, specverseValue, target) {
+  const componentMapping = COMPONENT_SPECIFIC_MAPPINGS[componentType]?.[propertyName]?.[specverseValue];
+  if (componentMapping && target in componentMapping) {
+    return true;
+  }
+  const commonMapping = COMMON_PROPERTY_MAPPINGS[propertyName]?.[specverseValue];
+  if (commonMapping && target in commonMapping) {
+    return true;
+  }
+  return false;
+}
+function getAllMappings(componentType, propertyName, specverseValue) {
+  const componentMapping = COMPONENT_SPECIFIC_MAPPINGS[componentType]?.[propertyName]?.[specverseValue];
+  if (componentMapping) {
+    return componentMapping;
+  }
+  const commonMapping = COMMON_PROPERTY_MAPPINGS[propertyName]?.[specverseValue];
+  if (commonMapping) {
+    return commonMapping;
+  }
+  return null;
+}
+export {
+  COLOR_MAPPING,
+  COMMON_PROPERTY_MAPPINGS,
+  COMPONENT_SPECIFIC_MAPPINGS,
+  FRAMEWORK_TARGETS,
+  ORIENTATION_MAPPING,
+  POSITION_MAPPING,
+  SIZE_MAPPING,
+  VARIANT_MAPPING,
+  getAllMappings,
+  getFrameworkTargets,
+  getSemanticMeaning,
+  hasMapping,
+  mapProperties,
+  mapProperty
+};