lutaml 0.10.19 → 0.11.2

data/frontend/src/types.ts

@@ -1,221 +0,0 @@
-export interface SpaCardinality {
-  min?: string
-  max?: string
-}
-
-export interface SpaAttribute {
-  id: string
-  name: string
-  type: string
-  visibility?: string
-  owner: string
-  ownerName: string
-  cardinality?: SpaCardinality
-  definition?: string
-  stereotypes: string[]
-  isStatic: boolean
-  isReadOnly: boolean
-  defaultValue?: string
-}
-
-export interface SpaAssociationEnd {
-  class?: string
-  className?: string
-  role?: string
-  cardinality?: SpaCardinality
-  aggregation?: string
-}
-
-export interface SpaAssociation {
-  id: string
-  xmiId: string
-  name: string
-  type: string
-  definition?: string
-  source?: SpaAssociationEnd
-  target?: SpaAssociationEnd
-}
-
-export interface SpaOperation {
-  id: string
-  name: string
-  visibility?: string
-  returnType?: string
-  owner: string
-  ownerName: string
-  parameters: SpaParameter[]
-  isStatic: boolean
-  isAbstract: boolean
-}
-
-export interface SpaParameter {
-  name: string
-  type?: string
-  direction?: string
-}
-
-export interface SpaLiteral {
-  name: string
-  definition?: string
-}
-
-export interface SpaInheritedAttribute {
-  attributeId: string
-  attribute: SpaAttribute
-  inheritedFrom: string
-  inheritedFromName: string
-  parentOrder: number
-}
-
-export interface SpaInheritedAssociation {
-  associationId: string
-  inheritedFrom: string
-  inheritedFromName: string
-  parentOrder: number
-  localRole: string
-}
-
-export interface SpaClass {
-  id: string
-  xmiId: string
-  name: string
-  qualifiedName: string
-  type: string
-  package?: string
-  stereotypes: string[]
-  definition?: string
-  attributes: string[]
-  operations: string[]
-  associations: string[]
-  generalizations: string[]
-  specializations: string[]
-  isAbstract: boolean
-  literals: SpaLiteral[]
-  inheritedAttributes: SpaInheritedAttribute[]
-  inheritedAssociations: SpaInheritedAssociation[]
-}
-
-export interface SpaPackage {
-  id: string
-  xmiId: string
-  name: string
-  path: string
-  definition?: string
-  stereotypes: string[]
-  classes: string[]
-  subPackages: string[]
-  diagrams: string[]
-  parent?: string
-}
-
-export interface SpaTreeClassRef {
-  id: string
-  name: string
-  stereotypes: string[]
-}
-
-export interface SpaPackageTreeNode {
-  id: string
-  name: string
-  path: string
-  stereotypes: string[]
-  classCount: number
-  classes: SpaTreeClassRef[]
-  children: SpaPackageTreeNode[]
-}
-
-export interface SpaDiagram {
-  id: string
-  xmiId: string
-  name: string
-  type: string
-  package?: string
-  objectCount: number
-  linkCount: number
-  svg?: string
-}
-
-export interface SpaStatistics {
-  packages: number
-  classes: number
-  associations: number
-  attributes: number
-  operations: number
-}
-
-export interface SpaLogoVariant {
-  path?: string
-  url?: string
-}
-
-export interface SpaLogoConfig {
-  light: SpaLogoVariant
-  dark: SpaLogoVariant
-}
-
-export interface SpaLogos {
-  square?: SpaLogoConfig
-  long?: SpaLogoConfig
-}
-
-export interface SpaAppearance {
-  logos?: SpaLogos
-}
-
-export interface SpaMetadata {
-  title?: string
-  description?: string
-  generated: string
-  generator: string
-  version: string
-  homepage?: string
-  repository?: string
-  license?: string
-  authors?: string
-  tags?: string[]
-  appearance?: SpaAppearance
-  statistics: SpaStatistics
-}
-
-export interface SpaSearchEntry {
-  id: string
-  type: string
-  entityType: string
-  entityId: string
-  name: string
-  qualifiedName: string
-  package: string
-  content: string
-  boost: number
-}
-
-export interface SpaSearchIndex {
-  version: string
-  fields: { name: string; boost: number }[]
-  ref: string
-  documentStore: SpaSearchEntry[]
-  pipeline: string[]
-}
-
-export interface SpaDocument {
-  metadata: SpaMetadata
-  packageTree: SpaPackageTreeNode
-  packages: Record<string, SpaPackage>
-  classes: Record<string, SpaClass>
-  attributes: Record<string, SpaAttribute>
-  associations: Record<string, SpaAssociation>
-  operations: Record<string, SpaOperation>
-  diagrams: Record<string, SpaDiagram>
-}
-
-export interface SpaData {
-  metadata: SpaMetadata
-  packageTree: SpaPackageTreeNode
-  packages: Record<string, SpaPackage>
-  classes: Record<string, SpaClass>
-  attributes: Record<string, SpaAttribute>
-  associations: Record<string, SpaAssociation>
-  operations: Record<string, SpaOperation>
-  diagrams: Record<string, SpaDiagram>
-  searchIndex: SpaSearchIndex
-}

data/frontend/tests/e2e/render.spec.ts

@@ -1,188 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import puppeteer, { type Browser, type Page } from 'puppeteer'
-import path from 'path'
-import fs from 'fs'
-
-const NEW_HTML = '/tmp/lutaml_test_new.html'
-const SCREENSHOT_DIR = path.join(__dirname, '__screenshots__')
-
-describe('Lutaml SPA rendering', () => {
-  let browser: Browser
-  let page: Page
-  const consoleErrors: string[] = []
-
-  beforeAll(async () => {
-    fs.mkdirSync(SCREENSHOT_DIR, { recursive: true })
-
-    browser = await puppeteer.launch({
-      headless: true,
-      args: ['--no-sandbox', '--disable-setuid-sandbox'],
-    })
-    page = await browser.newPage()
-    await page.setViewport({ width: 1280, height: 800 })
-
-    page.on('pageerror', (err) => {
-      consoleErrors.push(`PageError: ${err.message}`)
-    })
-    page.on('console', (msg) => {
-      if (msg.type() === 'error') {
-        consoleErrors.push(`ConsoleError: ${msg.text()}`)
-      }
-    })
-  })
-
-  afterAll(async () => {
-    await browser.close()
-  })
-
-  it('loads without JS errors', async () => {
-    await page.goto(`file://${NEW_HTML}`, { waitUntil: 'networkidle0', timeout: 10000 })
-
-    // Wait for Vue to mount
-    await page.waitForSelector('#app', { timeout: 5000 })
-    await new Promise((r) => setTimeout(r, 500))
-
-    const criticalErrors = consoleErrors.filter(
-      (e) =>
-        !e.includes('favicon') &&
-        !e.includes('fonts.googleapis.com') &&
-        !e.includes('Download the React DevTools')
-    )
-    expect(criticalErrors).toEqual([])
-  })
-
-  it('renders the sidebar', async () => {
-    const sidebar = await page.$('.sidebar')
-    expect(sidebar).not.toBeNull()
-
-    const branding = await page.$('.sidebar-branding')
-    expect(branding).not.toBeNull()
-
-    const overviewBtn = await page.$('.overview-btn')
-    expect(overviewBtn).not.toBeNull()
-  })
-
-  it('renders the header', async () => {
-    const header = await page.$('.header')
-    expect(header).not.toBeNull()
-
-    const searchTrigger = await page.$('.search-trigger')
-    expect(searchTrigger).not.toBeNull()
-
-    const themeBtn = await page.$('.theme-btn')
-    expect(themeBtn).not.toBeNull()
-  })
-
-  it('renders the package tree', async () => {
-    const treeNodes = await page.$$('.tree-node')
-    expect(treeNodes.length).toBeGreaterThan(0)
-  })
-
-  it('renders the welcome view by default', async () => {
-    const welcome = await page.$('.view-welcome')
-    expect(welcome).not.toBeNull()
-
-    const stats = await page.$$('.welcome-stat')
-    expect(stats.length).toBeGreaterThan(0)
-  })
-
-  it('takes a screenshot of the welcome page', async () => {
-    await page.screenshot({
-      path: path.join(SCREENSHOT_DIR, 'new-welcome.png'),
-      fullPage: false,
-    })
-  })
-
-  it('toggles dark mode', async () => {
-    // Check initial theme
-    const initialTheme = await page.evaluate(() => {
-      return document.querySelector('.app-layout')?.getAttribute('data-theme')
-    })
-    expect(initialTheme).toBe('light')
-
-    // Click theme toggle
-    await page.click('.theme-btn')
-    await new Promise((r) => setTimeout(r, 200))
-
-    const darkTheme = await page.evaluate(() => {
-      return document.querySelector('.app-layout')?.getAttribute('data-theme')
-    })
-    expect(darkTheme).toBe('dark')
-
-    await page.screenshot({
-      path: path.join(SCREENSHOT_DIR, 'new-dark-mode.png'),
-      fullPage: false,
-    })
-
-    // Toggle back
-    await page.click('.theme-btn')
-    await new Promise((r) => setTimeout(r, 200))
-  })
-
-  it('collapses and expands sidebar', async () => {
-    // Sidebar should be visible initially
-    const sidebarClass = await page.evaluate(() => {
-      return document.querySelector('.sidebar')?.className
-    })
-    expect(sidebarClass).not.toContain('collapsed')
-
-    // Click sidebar toggle
-    await page.click('.sidebar-toggle')
-    await new Promise((r) => setTimeout(r, 300))
-
-    const collapsedClass = await page.evaluate(() => {
-      return document.querySelector('.sidebar')?.className
-    })
-    expect(collapsedClass).toContain('collapsed')
-
-    await page.screenshot({
-      path: path.join(SCREENSHOT_DIR, 'new-sidebar-collapsed.png'),
-      fullPage: false,
-    })
-
-    // Expand again
-    await page.click('.sidebar-toggle')
-    await new Promise((r) => setTimeout(r, 300))
-  })
-
-  it('opens search modal with / key', async () => {
-    await page.keyboard.press('/')
-    await new Promise((r) => setTimeout(r, 200))
-
-    const modal = await page.$('.search-modal-overlay')
-    expect(modal).not.toBeNull()
-
-    await page.screenshot({
-      path: path.join(SCREENSHOT_DIR, 'new-search-modal.png'),
-      fullPage: false,
-    })
-
-    // Close
-    await page.keyboard.press('Escape')
-    await new Promise((r) => setTimeout(r, 200))
-  })
-
-  it('clicks a package in the tree and shows details', async () => {
-    // Click the first package label in the tree
-    const clicked = await page.evaluate(() => {
-      const label = document.querySelector('.tree-label') as HTMLElement
-      if (label) {
-        label.click()
-        return true
-      }
-      return false
-    })
-    expect(clicked).toBe(true)
-
-    await new Promise((r) => setTimeout(r, 300))
-
-    // Should show package details or class details
-    const detailView = await page.$('.detail-view')
-    expect(detailView).not.toBeNull()
-
-    await page.screenshot({
-      path: path.join(SCREENSHOT_DIR, 'new-package-details.png'),
-      fullPage: false,
-    })
-  })
-})

data/frontend/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "jsx": "preserve",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "esModuleInterop": true,
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "skipLibCheck": true,
-    "noEmit": true,
-    "paths": {
-      "@/*": ["./src/*"]
-    }
-  },
-  "include": ["src/**/*.ts", "src/**/*.vue"],
-  "exclude": ["node_modules", "dist"]
-}

data/frontend/vite.config.ts

@@ -1,26 +0,0 @@
-import { defineConfig } from 'vite'
-import vue from '@vitejs/plugin-vue'
-import { resolve } from 'path'
-
-export default defineConfig({
-  plugins: [vue()],
-  define: {
-    'process.env.NODE_ENV': JSON.stringify('production'),
-  },
-  build: {
-    lib: {
-      entry: resolve(__dirname, 'src/app.ts'),
-      name: 'LutamlUmlSpa',
-      formats: ['iife'],
-      fileName: () => 'app.iife.js',
-    },
-    rollupOptions: {
-      external: [],
-      output: {
-        assetFileNames: 'style.[ext]',
-      },
-    },
-    outDir: 'dist',
-    emptyOutDir: true,
-  },
-})

data/frontend/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    testTimeout: 30000,
-    hookTimeout: 30000,
-  },
-})

data/lib/lutaml/cli/element_identifier.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Cli
-    # ElementIdentifier parses and manages element references
-    #
-    # Provides a unified syntax for referring to UML elements:
-    # - "package:ModelRoot::Core"
-    # - "class:ModelRoot::Core::Building"
-    # - "diagram:ClassDiagram1"
-    # - "attribute:ModelRoot::Core::Building::name"
-    #
-    # Supports auto-detection when type prefix is omitted.
-    #
-    # @example Parse an identifier with explicit type
-    #   id = ElementIdentifier.parse("class:Building")
-    #   id.type # => :class
-    #   id.path # => "Building"
-    #
-    # @example Parse an identifier with auto-detection
-    #   id = ElementIdentifier.parse("ModelRoot::Core::Building")
-    #   id.type # => :class (auto-detected from pattern)
-    #   id.path # => "ModelRoot::Core::Building"
-    class ElementIdentifier
-      attr_reader :type, :path
-
-      # Parse an element identifier string
-      #
-      # @param identifier [String] Element identifier in format "type:path"
-      # or just "path"
-      # @return [ElementIdentifier] Parsed identifier
-      # @raise [ArgumentError] If identifier is invalid or type is not
-      # registered
-      def self.parse(identifier) # rubocop:disable Metrics/MethodLength
-        if identifier.nil? || identifier.empty?
-          raise ArgumentError,
-                "Identifier cannot be nil or empty"
-        end
-
-        if identifier.include?(":")
-          type, path = identifier.split(":", 2)
-          type_sym = type.to_sym
-
-          unless ResourceRegistry.type_registered?(type_sym)
-            raise ArgumentError, "Unknown element type: #{type}. " \
-                                 "Valid types: " \
-                                 "#{ResourceRegistry.types.join(', ')}"
-          end
-
-          new(type_sym, path)
-        else
-          # Auto-detect type from pattern
-          detected_type = detect_type(identifier)
-          new(detected_type, identifier)
-        end
-      end
-
-      # Initialize an identifier
-      #
-      # @param type [Symbol] Element type
-      # @param path [String] Element path/name
-      def initialize(type, path)
-        @type = type
-        @path = path
-      end
-
-      # Get a human-readable string representation
-      #
-      # @return [String] String representation
-      def to_s
-        "#{type}:#{path}"
-      end
-
-      # Check if this identifier has an explicit type prefix
-      #
-      # @param identifier [String] Identifier string
-      # @return [Boolean] True if has explicit type prefix
-      def self.has_type_prefix?(identifier)
-        identifier.include?(":") &&
-          ResourceRegistry.type_registered?(identifier.split(":",
-                                                             2).first.to_sym)
-      end
-
-      # Detect element type from identifier pattern
-      #
-      # Uses heuristics to determine type:
-      # - Multiple :: separators → likely a class
-      # - Starts with uppercase → likely a class or package
-      # - Contains "Diagram" → likely a diagram
-      # - Otherwise → package (safest default)
-      #
-      # @param identifier [String] Identifier without type prefix
-      # @return [Symbol] Detected type
-      def self.detect_type(identifier) # rubocop:disable Metrics/MethodLength
-        # Check for diagram patterns
-        return :diagram if identifier.match?(/diagram/i)
-
-        # Count package separators
-        separator_count = identifier.scan("::").size
-
-        case separator_count
-        when 0
-          # No separators - single name
-          # Could be package, class, or diagram
-          if identifier.match?(/^[A-Z]/)
-            # Starts with uppercase - likely a class or package name
-            # Default to package as it's more general
-            :package
-          else
-            # Lowercase start - could be attribute or diagram name
-            :diagram
-          end
-        when 1..Float::INFINITY
-          # One or more separators - likely qualified class name
-          # e.g., Package::Class or ModelRoot::Package::Class
-          :class
-        else
-          # Default
-          :package
-        end
-      end
-
-      # Check if identifier is a qualified name (contains ::)
-      #
-      # @return [Boolean] True if qualified
-      def qualified?
-        @path.include?("::")
-      end
-
-      # Get the simple name (last component after ::)
-      #
-      # @return [String] Simple name
-      def simple_name
-        qualified? ? @path.split("::").last : @path
-      end
-
-      # Get the parent path (everything before last ::)
-      #
-      # @return [String, nil] Parent path or nil if not qualified
-      def parent_path
-        return nil unless qualified?
-
-        parts = @path.split("::")
-        parts[0...-1].join("::")
-      end
-
-      # Convert to hash representation
-      #
-      # @return [Hash] Hash with type and path keys
-      def to_h
-        {
-          type: @type,
-          path: @path,
-          simple_name: simple_name,
-          qualified: qualified?,
-        }
-      end
-    end
-  end
-end