lutaml-jsonschema 0.1.16 → 0.1.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a225cce2d635b5a3d8b1376087e61b6f20e319ed84b34bc543812279bb7c6f2
-  data.tar.gz: 394d28b298c43654eb7d6f6614b310ef31311a0e51d6a537f41b70e947010fa6
+  metadata.gz: a510965cb5b2a1815007d9e5ae6dbd587d4ac431b6b5c600324f855e33443ca5
+  data.tar.gz: 74c3d962eaabbe06518b32d4366b4ca4f017cef900cc3ce6610c8a3ebbcc705a
 SHA512:
-  metadata.gz: 6f1f62960e78d9e07ac390fc37ab7c8e0853cbaeaefdaa12843bc41ceb17aecfdaa2193dcf26e382034008b4377fcedfad4094648ce858a611b431cfe78ead7c
-  data.tar.gz: 9f1e1c38bd3335511264282a1e5d49cb74b4bb850a43ee58355fb64b422efb68415b778eda4540a79fbaf933bc265a583b0089b85b8bb5843da0709b9ddafd4e
+  metadata.gz: 52e34466cd3d104c64746aeecfe69e8c79b44fcb8e75bc3c2005b3a79027838422e480486ae44dc0b9cae2c40fbc1fcba68e8da0950f272e01695d5fe3f53783
+  data.tar.gz: 380679dc0b84274ee54ea25fa0860b93e041e98020b17947e9673a5c75a83022f1ee144afc746d31b27650d467fe9b77ac14801f63175ae531e49fac1abe71d2

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-05-14 10:12:34 UTC using RuboCop version 1.86.1.
+# on 2026-05-27 07:40:36 UTC using RuboCop version 1.86.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -11,15 +11,38 @@ Gemspec/RequiredRubyVersion:
   Exclude:
     - 'lutaml-jsonschema.gemspec'
 
-# Offense count: 1
+# Offense count: 2
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: EnforcedStyle, IndentationWidth.
+# SupportedStyles: with_first_element, with_fixed_indentation
+Layout/ArrayAlignment:
+  Exclude:
+    - 'spec/lutaml/spa_builder_spec.rb'
+
+# Offense count: 5
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: EnforcedStyleAlignWith.
 # SupportedStylesAlignWith: either, start_of_block, start_of_line
 Layout/BlockAlignment:
   Exclude:
     - 'lib/lutaml/jsonschema/spa/spa_builder.rb'
+    - 'spec/lutaml/spa_builder_spec.rb'
+
+# Offense count: 4
+# This cop supports safe autocorrection (--autocorrect).
+Layout/BlockEndNewline:
+  Exclude:
+    - 'spec/lutaml/spa_builder_spec.rb'
+
+# Offense count: 8
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: Width, EnforcedStyleAlignWith, AllowedPatterns.
+# SupportedStylesAlignWith: start_of_line, relative_to_receiver
+Layout/IndentationWidth:
+  Exclude:
+    - 'spec/lutaml/spa_builder_spec.rb'
 
-# Offense count: 28
+# Offense count: 34
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
@@ -62,7 +85,7 @@ Metrics/AbcSize:
     - 'lib/lutaml/jsonschema/schema_set.rb'
     - 'lib/lutaml/jsonschema/spa/spa_builder.rb'
 
-# Offense count: 3
+# Offense count: 5
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 # AllowedMethods: refine
 Metrics/BlockLength:
@@ -78,7 +101,7 @@ Metrics/CyclomaticComplexity:
     - 'lib/lutaml/jsonschema/reference_resolver.rb'
     - 'lib/lutaml/jsonschema/schema_set.rb'
 
-# Offense count: 17
+# Offense count: 18
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 47
@@ -107,6 +130,17 @@ Naming/PredicateMethod:
   Exclude:
     - 'lib/lutaml/jsonschema/schema_set.rb'
 
+# Offense count: 7
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: EnforcedStyle, ProceduralMethods, FunctionalMethods, AllowedMethods, AllowedPatterns, AllowBracesOnProceduralOneLiners, BracesRequiredMethods.
+# SupportedStyles: line_count_based, semantic, braces_for_chaining, always_braces
+# ProceduralMethods: benchmark, bm, bmbm, create, each_with_object, measure, new, realtime, tap, with_object
+# FunctionalMethods: let, let!, subject, watch
+# AllowedMethods: lambda, proc, it
+Style/BlockDelimiters:
+  Exclude:
+    - 'spec/lutaml/spa_builder_spec.rb'
+
 # Offense count: 2
 # This cop supports unsafe autocorrection (--autocorrect-all).
 Style/IdenticalConditionalBranches:

data/frontend/src/__tests__/spaDataCompleteness.test.ts

@@ -0,0 +1,338 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { describe, it, expect, beforeEach } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import { useSchemaStore } from '../stores/schemaStore'
+import {
+  primaryType,
+  displayType,
+  refLabel,
+  humanizeConstraints,
+  hasConstraints,
+} from '../composables/useSchemaTypes'
+import { resolveSchemaRef } from '../composables/useDefinitionResolver'
+import { createField, buildDefaultJson } from '../composables/useBuilderField'
+import type { SpaDocument, SpaProperty, SpaDefinition, SpaSchema } from '../types'
+
+function prop(overrides: Partial<SpaProperty> = {}): SpaProperty {
+  return { name: 'test', ...overrides }
+}
+
+function definition(overrides: Partial<SpaDefinition> = {}): SpaDefinition {
+  return { name: 'Test', properties: [], required: [], ...overrides }
+}
+
+function schema(overrides: Partial<SpaSchema> = {}): SpaSchema {
+  return { name: 'TestSchema', properties: [], definitions: [], required: [], ...overrides }
+}
+
+/**
+ * Build a SpaDocument that mimics what the Ruby backend outputs
+ * for a complex schema like ISO 19115-4 mdj.json.
+ */
+function buildComplexDoc(): SpaDocument {
+  const mdIdentifier: SpaDefinition = {
+    name: 'MD_Identifier',
+    title: 'Identifier',
+    type: 'object',
+    properties: [
+      prop({ name: 'code', type: 'string', required: true }),
+      prop({ name: 'codeSpace', type: 'string', format: 'uri' }),
+    ],
+    required: ['code'],
+  }
+
+  const topicCategory: SpaDefinition = {
+    name: 'MD_TopicCategoryCode',
+    title: 'Topic Category',
+    type: 'string',
+    enum: ['farming', 'biota', 'boundaries', 'climatology', 'economy', 'elevation'],
+    properties: [],
+    required: [],
+  }
+
+  const obligationCode: SpaDefinition = {
+    name: 'MD_ObligationCode',
+    type: 'string',
+    enum: ['mandatory', 'optional', 'conditional'],
+    properties: [],
+    required: [],
+  }
+
+  const ciTelephone: SpaDefinition = {
+    name: 'CI_Telephone',
+    type: 'object',
+    properties: [
+      prop({ name: 'number', type: 'string' }),
+    ],
+    required: [],
+  }
+
+  const durationType: SpaDefinition = {
+    name: 'DurationType',
+    type: 'string',
+    format: 'duration',
+    pattern: '^P.*$',
+    properties: [],
+    required: [],
+  }
+
+  const constraintUnion: SpaDefinition = {
+    name: 'Abstract_ConstraintUnion',
+    hasOneOf: true,
+    properties: [],
+    required: [],
+  }
+
+  const mdMetadata: SpaDefinition = {
+    name: 'MD_Metadata',
+    title: 'Metadata',
+    type: 'object',
+    description: 'Root metadata object',
+    properties: [
+      prop({ name: 'name', type: 'string', required: true }),
+      prop({
+        name: 'identifiers',
+        type: 'array',
+        itemsType: 'object',
+        itemsRef: '#/$defs/MD_Identifier',
+      }),
+      prop({
+        name: 'topicCategory',
+        ref: '#/$defs/MD_TopicCategoryCode',
+        type: 'string',
+        enum: ['farming', 'biota', 'boundaries', 'climatology', 'economy', 'elevation'],
+      }),
+      prop({
+        name: 'contacts',
+        type: 'array',
+        itemsType: 'object',
+        itemsRef: '#/$defs/CI_Contact',
+        minItems: 1,
+      }),
+    ],
+    required: ['name'],
+  }
+
+  const ciContact: SpaDefinition = {
+    name: 'CI_Contact',
+    type: 'object',
+    properties: [
+      prop({
+        name: 'phone',
+        type: 'array',
+        itemsType: 'object',
+        itemsRef: '#/$defs/CI_Telephone',
+      }),
+    ],
+    required: [],
+  }
+
+  return {
+    metadata: { title: 'ISO 19115-4 Metadata' },
+    schemas: [{
+      name: 'mdj',
+      title: 'ISO 19115-4',
+      type: 'object',
+      properties: [],
+      definitions: [
+        mdMetadata,
+        mdIdentifier,
+        topicCategory,
+        obligationCode,
+        ciContact,
+        ciTelephone,
+        durationType,
+        constraintUnion,
+      ],
+      required: [],
+      sourceJson: '{}',
+    }],
+    searchIndex: [],
+  }
+}
+
+describe('SPA data completeness for complex schemas', () => {
+  let store: ReturnType<typeof useSchemaStore>
+
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    store = useSchemaStore()
+  })
+
+  describe('backend data integrity', () => {
+    const doc = buildComplexDoc()
+
+    it('array properties have itemsRef resolved from items.$ref', () => {
+      const mdMetadata = doc.schemas[0].definitions.find(d => d.name === 'MD_Metadata')!
+      const identifiers = mdMetadata.properties.find(p => p.name === 'identifiers')!
+      expect(identifiers.itemsRef).toBe('#/$defs/MD_Identifier')
+      expect(identifiers.itemsType).toBe('object')
+    })
+
+    it('array properties with itemsRef show correct display type', () => {
+      const mdMetadata = doc.schemas[0].definitions.find(d => d.name === 'MD_Metadata')!
+      const identifiers = mdMetadata.properties.find(p => p.name === 'identifiers')!
+      expect(displayType(identifiers)).toBe('array of MD_Identifier')
+    })
+
+    it('enum definitions carry their enum values', () => {
+      const topicCat = doc.schemas[0].definitions.find(d => d.name === 'MD_TopicCategoryCode')!
+      expect(topicCat.enum).toHaveLength(6)
+      expect(topicCat.enum).toContain('farming')
+      expect(topicCat.enum).toContain('elevation')
+    })
+
+    it('properties resolved from enum definitions carry enum values', () => {
+      const mdMetadata = doc.schemas[0].definitions.find(d => d.name === 'MD_Metadata')!
+      const topic = mdMetadata.properties.find(p => p.name === 'topicCategory')!
+      expect(topic.enum).toHaveLength(6)
+      expect(topic.ref).toBe('#/$defs/MD_TopicCategoryCode')
+    })
+
+    it('format and pattern on non-object definitions are preserved', () => {
+      const duration = doc.schemas[0].definitions.find(d => d.name === 'DurationType')!
+      expect(duration.format).toBe('duration')
+      expect(duration.pattern).toBe('^P.*$')
+    })
+
+    it('minItems on array properties is preserved', () => {
+      const mdMetadata = doc.schemas[0].definitions.find(d => d.name === 'MD_Metadata')!
+      const contacts = mdMetadata.properties.find(p => p.name === 'contacts')!
+      expect(contacts.minItems).toBe(1)
+    })
+
+    it('nested array itemsRef through definition chain', () => {
+      const ciContact = doc.schemas[0].definitions.find(d => d.name === 'CI_Contact')!
+      const phone = ciContact.properties.find(p => p.name === 'phone')!
+      expect(phone.itemsRef).toBe('#/$defs/CI_Telephone')
+    })
+
+    it('hasOneOf flag on union definitions', () => {
+      const constraint = doc.schemas[0].definitions.find(d => d.name === 'Abstract_ConstraintUnion')!
+      expect(constraint.hasOneOf).toBe(true)
+    })
+  })
+
+  describe('frontend rendering with store', () => {
+    it('store loads complex document and resolves definitions', () => {
+      window.SCHEMA_DATA = buildComplexDoc() as any
+      store.loadFromWindow()
+
+      const schemas = store.schemas
+      expect(schemas).toHaveLength(1)
+      expect(schemas[0].definitions).toHaveLength(8)
+    })
+
+    it('store normalizes $ref → ref on nested definition properties', () => {
+      const doc = buildComplexDoc()
+      // Simulate backend output where $ref is the JSON key
+      const topicProp = doc.schemas[0].definitions[0].properties.find(p => p.name === 'topicCategory')!
+      ;(topicProp as any).$ref = topicProp.ref
+      delete topicProp.ref
+
+      window.SCHEMA_DATA = doc as any
+      store.loadFromWindow()
+
+      const mdMetadata = store.schemas[0].definitions.find(d => d.name === 'MD_Metadata')!
+      const topic = mdMetadata.properties.find(p => p.name === 'topicCategory')!
+      expect(topic.ref).toBe('#/$defs/MD_TopicCategoryCode')
+      expect((topic as any).$ref).toBeUndefined()
+    })
+
+    it('definition resolver finds enum definitions', () => {
+      const s = schema({
+        definitions: [
+          definition({ name: 'MD_TopicCategoryCode', type: 'string', enum: ['farming', 'biota'] }),
+        ],
+      })
+      const resolved = resolveSchemaRef('#/$defs/MD_TopicCategoryCode', s)
+      expect(resolved).not.toBeNull()
+      expect(resolved!.enum).toEqual(['farming', 'biota'])
+    })
+  })
+
+  describe('type display for complex schema patterns', () => {
+    it('refLabel extracts definition name from $defs path', () => {
+      expect(refLabel('#/$defs/MD_Identifier')).toBe('MD_Identifier')
+    })
+
+    it('refLabel handles definitions path', () => {
+      expect(refLabel('#/definitions/address')).toBe('address')
+    })
+
+    it('displayType for array with itemsRef', () => {
+      expect(displayType(prop({ type: 'array', itemsRef: '#/$defs/MD_Identifier' }))).toBe('array of MD_Identifier')
+    })
+
+    it('prefers itemsRef label when itemsType is generic object', () => {
+      expect(displayType(prop({ type: 'array', itemsType: 'object', itemsRef: '#/$defs/Foo' }))).toBe('array of Foo')
+    })
+
+    it('uses itemsType when it is a specific primitive type', () => {
+      expect(displayType(prop({ type: 'array', itemsType: 'string', itemsRef: '#/$defs/Foo' }))).toBe('array of string')
+    })
+
+    it('displayType for array with itemsRef and constraints', () => {
+      const p = prop({ type: 'array', itemsRef: '#/$defs/MD_Identifier', minItems: 1, maxItems: 10 })
+      expect(displayType(p)).toBe('array of MD_Identifier [ 1 .. 10 ]')
+    })
+
+    it('displayType for nullable array with itemsRef', () => {
+      expect(displayType(prop({ type: 'array,null', itemsRef: '#/$defs/Item' }))).toBe('array of Item | null')
+    })
+  })
+
+  describe('builder field creation for complex properties', () => {
+    it('creates field for array property with itemsRef', () => {
+      const p = prop({ name: 'ids', type: 'array', itemsType: 'object', itemsRef: '#/$defs/MD_Identifier' })
+      const s = schema({
+        definitions: [definition({ name: 'MD_Identifier', type: 'object', properties: [prop({ name: 'code', type: 'string' })], required: [] })],
+      })
+      const field = createField(p, [], s)
+      expect(field.arrayItems).toHaveLength(1)
+      expect(field.resolvedDef).toBeNull()
+    })
+
+    it('creates field for property resolved from enum definition', () => {
+      const p = prop({
+        name: 'topic',
+        ref: '#/$defs/MD_TopicCategoryCode',
+        type: 'string',
+        enum: ['farming', 'biota', 'boundaries'],
+      })
+      const s = schema({
+        definitions: [definition({ name: 'MD_TopicCategoryCode', type: 'string', enum: ['farming', 'biota', 'boundaries'], properties: [], required: [] })],
+      })
+      const field = createField(p, [], s)
+      // Enum property should have first enum as initial value
+      expect(field.rawValue).toBe('farming')
+    })
+
+    it('buildDefaultJson handles array items with itemsRef', () => {
+      const props = [
+        prop({ name: 'tags', type: 'array', itemsType: 'string' }),
+      ]
+      const json = buildDefaultJson(props)
+      expect(json.tags).toEqual([''])
+    })
+  })
+
+  describe('constraint chips for complex definitions', () => {
+    it('enum definition has constraints detected via property resolver', () => {
+      const p = prop({
+        name: 'topic',
+        type: 'string',
+        enum: ['farming', 'biota'],
+        ref: '#/$defs/MD_TopicCategoryCode',
+      })
+      expect(hasConstraints(p)).toBe(true)
+    })
+
+    it('array with itemsRef and minItems has constraints', () => {
+      const p = prop({ name: 'items', type: 'array', itemsRef: '#/$defs/X', minItems: 1 })
+      expect(hasConstraints(p)).toBe(true)
+    })
+  })
+})

data/frontend/src/__tests__/useSchemaTypes.test.ts

@@ -17,6 +17,7 @@ import {
   numberRange,
   stringRange,
   itemsRange,
+  refLabel,
 } from '../composables/useSchemaTypes'
 import type { SpaProperty } from '../types'
 
@@ -86,6 +87,28 @@ describe('displayType', () => {
   it('shows array without itemsType', () => {
     expect(displayType(prop({ type: 'array' }))).toBe('array')
   })
+
+  it('shows array with itemsRef when itemsType is missing', () => {
+    expect(displayType(prop({ type: 'array', itemsRef: '#/$defs/MD_Identifier' }))).toBe('array of MD_Identifier')
+  })
+
+  it('prefers itemsType over itemsRef when both present', () => {
+    expect(displayType(prop({ type: 'array', itemsType: 'string', itemsRef: '#/$defs/SomeDef' }))).toBe('array of string')
+  })
+})
+
+describe('refLabel', () => {
+  it('extracts last segment from $defs ref', () => {
+    expect(refLabel('#/$defs/MD_Identifier')).toBe('MD_Identifier')
+  })
+
+  it('extracts last segment from definitions ref', () => {
+    expect(refLabel('#/definitions/address')).toBe('address')
+  })
+
+  it('returns last segment for any path', () => {
+    expect(refLabel('#/a/b/c')).toBe('c')
+  })
 })
 
 describe('formatInputType', () => {

data/frontend/src/components/DetailPanel.vue

@@ -140,6 +140,30 @@
                   <span class="meta-label">Additional</span>
                   <span class="badge badge-locked-detail">Denied</span>
                 </div>
+                <div v-if="definitionItem?.format" class="meta-row">
+                  <span class="meta-label">Format</span>
+                  <span class="badge badge-format">{{ definitionItem.format }}</span>
+                </div>
+                <div v-if="definitionItem?.pattern" class="meta-row">
+                  <span class="meta-label">Pattern</span>
+                  <span class="font-mono constraint-pattern">{{ definitionItem.pattern }}</span>
+                </div>
+                <div v-if="definitionItem?.default" class="meta-row">
+                  <span class="meta-label">Default</span>
+                  <span class="font-mono">{{ definitionItem.default }}</span>
+                </div>
+                <div v-if="definitionItem?.minLength != null || definitionItem?.maxLength != null" class="meta-row">
+                  <span class="meta-label">Length</span>
+                  <span class="text-secondary">{{ defStringRange }}</span>
+                </div>
+                <div v-if="definitionItem?.minimum != null || definitionItem?.maximum != null || definitionItem?.exclusiveMinimum != null || definitionItem?.exclusiveMaximum != null" class="meta-row">
+                  <span class="meta-label">Range</span>
+                  <span class="text-secondary">{{ defNumberRange }}</span>
+                </div>
+                <div v-if="definitionItem?.multipleOf != null" class="meta-row">
+                  <span class="meta-label">Multiple Of</span>
+                  <span class="text-secondary">{{ definitionItem.multipleOf }}</span>
+                </div>
               </div>
             </div>
 
@@ -173,9 +197,12 @@
                       </div>
                     </td>
                   </tr>
-                  <tr v-if="propertyItem.itemsType">
+                  <tr v-if="propertyItem.itemsType || propertyItem.itemsRef">
                     <td class="constraint-key">Items Type</td>
-                    <td class="constraint-value">{{ propertyItem.itemsType }}</td>
+                    <td class="constraint-value">
+                      {{ propertyItem.itemsType || 'object' }}
+                      <span v-if="propertyItem.itemsRef" class="prop-ref-link" role="button" tabindex="0" @click.stop="navigateToRef(propertyItem.itemsRef)" @keydown.enter="navigateToRef(propertyItem.itemsRef)"> → {{ refName(propertyItem.itemsRef) }}</span>
+                    </td>
                   </tr>
                   <tr v-if="propertyItem.uniqueItems">
                     <td class="constraint-key">Unique Items</td>
@@ -204,6 +231,52 @@
                 </tbody>
               </table>
             </div>
+
+            <!-- Constraints for definition (enum, pattern, etc.) -->
+            <div v-if="definitionItem && hasDefConstraints" class="detail-section">
+              <h3 class="detail-heading">Constraints</h3>
+              <table class="table constraint-table">
+                <tbody>
+                  <tr v-if="definitionItem.enum?.length">
+                    <td class="constraint-key">Enum</td>
+                    <td>
+                      <div class="enum-values-list">
+                        <span v-for="e in visibleEnumValues(definitionItem.name, definitionItem.enum)" :key="e" class="enum-value-chip">{{ e }}</span>
+                        <button v-if="definitionItem.enum.length > 8 && !detailEnumExpanded.has(definitionItem.name)" class="enum-more-btn" @click="toggleDetailEnum(definitionItem.name)">+{{ definitionItem.enum.length - 8 }} more</button>
+                      </div>
+                    </td>
+                  </tr>
+                  <tr v-if="definitionItem.const">
+                    <td class="constraint-key">Const</td>
+                    <td class="constraint-value font-mono">{{ definitionItem.const }}</td>
+                  </tr>
+                  <tr v-if="definitionItem.pattern">
+                    <td class="constraint-key">Pattern</td>
+                    <td class="constraint-value font-mono constraint-pattern">{{ definitionItem.pattern }}</td>
+                  </tr>
+                  <tr v-if="definitionItem.minimum != null || definitionItem.maximum != null || definitionItem.exclusiveMinimum != null || definitionItem.exclusiveMaximum != null">
+                    <td class="constraint-key">Range</td>
+                    <td class="constraint-value">{{ defNumberRange }}</td>
+                  </tr>
+                  <tr v-if="definitionItem.minLength != null || definitionItem.maxLength != null">
+                    <td class="constraint-key">Length</td>
+                    <td class="constraint-value">{{ defStringRange }}</td>
+                  </tr>
+                  <tr v-if="definitionItem.multipleOf != null">
+                    <td class="constraint-key">Multiple Of</td>
+                    <td class="constraint-value">{{ definitionItem.multipleOf }}</td>
+                  </tr>
+                  <tr v-if="definitionItem.contentMediaType">
+                    <td class="constraint-key">Content Type</td>
+                    <td class="constraint-value">{{ definitionItem.contentMediaType }}</td>
+                  </tr>
+                  <tr v-if="definitionItem.contentEncoding">
+                    <td class="constraint-key">Content Encoding</td>
+                    <td class="constraint-value">{{ definitionItem.contentEncoding }}</td>
+                  </tr>
+                </tbody>
+              </table>
+            </div>
           </template>
 
           <!-- Properties/Definition tab -->
@@ -231,6 +304,7 @@
                         <span class="prop-type-badge" :class="propTypeClass(prop.type)">{{ prop.type || 'any' }}</span>
                         <span v-if="prop.format" class="prop-format">&lt;{{ prop.format }}&gt;</span>
                         <span v-if="prop.itemsType" class="prop-format">[{{ prop.itemsType }}]</span>
+                        <span v-if="prop.itemsRef" class="prop-format">[<span class="prop-ref-link" role="button" tabindex="0" @click.stop="navigateToRef(prop.itemsRef)" @keydown.enter="navigateToRef(prop.itemsRef)">{{ refName(prop.itemsRef) }}</span>]</span>
                       </template>
                       <span v-if="prop.default != null" class="prop-default">default: {{ prop.default }}</span>
                       <span v-if="prop.enum?.length" class="prop-enum">{{ prop.enum.length }} values</span>
@@ -385,7 +459,7 @@ const hasConstraints = computed(() => {
   if (!p) return false
   return p.minimum != null || p.maximum != null ||
     p.minLength != null || p.maxLength != null ||
-    p.pattern || p.enum?.length || p.itemsType ||
+    p.pattern || p.enum?.length || p.itemsType || p.itemsRef ||
     p.exclusiveMinimum != null || p.exclusiveMaximum != null ||
     p.minItems != null || p.maxItems != null || p.uniqueItems ||
     p.multipleOf != null || p.const != null ||
@@ -393,6 +467,16 @@ const hasConstraints = computed(() => {
     p.additionalProperties === false
 })
 
+const hasDefConstraints = computed(() => {
+  const d = definitionItem.value
+  if (!d) return false
+  return d.enum?.length > 0 || !!d.const || !!d.pattern ||
+    d.minimum != null || d.maximum != null ||
+    d.exclusiveMinimum != null || d.exclusiveMaximum != null ||
+    d.minLength != null || d.maxLength != null ||
+    d.multipleOf != null || !!d.contentMediaType || !!d.contentEncoding
+})
+
 const numberRangeLabel = computed(() => {
   const p = propertyItem.value
   return p ? numberRange(p) ?? '' : ''
@@ -408,6 +492,18 @@ const itemsRangeLabel = computed(() => {
   return p ? itemsRange(p) ?? '' : ''
 })
 
+const defNumberRange = computed(() => {
+  const d = definitionItem.value
+  if (!d) return ''
+  return numberRange(d as any) ?? ''
+})
+
+const defStringRange = computed(() => {
+  const d = definitionItem.value
+  if (!d) return ''
+  return stringRange(d as any) ?? ''
+})
+
 type TabId = 'overview' | 'properties' | 'examples'
 
 const examples = computed(() => {

data/frontend/src/composables/useSchemaTypes.ts

@@ -15,6 +15,12 @@ export function isNullableType(type?: string): boolean {
   return (type || '').split(',').map(s => s.trim()).includes('null')
 }
 
+/** Extract the definition name from a $ref string (e.g. "#/$defs/MD_Identifier" → "MD_Identifier"). */
+export function refLabel(ref: string): string {
+  const parts = ref.split('/')
+  return parts[parts.length - 1]
+}
+
 /** Whether the type string is a composition indicator from the backend. */
 export function isCompositionType(type?: string): boolean {
   const t = type || ''
@@ -31,7 +37,10 @@ export function displayType(prop: SpaProperty, resolvedTitle?: string): string {
   const suffix = isNullableType(prop.type) ? ' | null' : ''
   if (isCompositionType(t)) return t + suffix
   if (t === 'array') {
-    let label = prop.itemsType ? `array of ${prop.itemsType}` : 'array'
+    const itemType = (prop.itemsRef && (!prop.itemsType || prop.itemsType === 'object'))
+      ? refLabel(prop.itemsRef)
+      : prop.itemsType
+    let label = itemType ? `array of ${itemType}` : 'array'
     if (prop.minItems != null && prop.maxItems != null) label += ` [ ${prop.minItems} .. ${prop.maxItems} ]`
     else if (prop.minItems != null) label += ` >= ${prop.minItems}`
     else if (prop.maxItems != null) label += ` <= ${prop.maxItems}`
@@ -144,7 +153,7 @@ export function isObjectProperty(prop: SpaProperty): boolean {
  */
 export function hasConstraints(prop: SpaProperty): boolean {
   return !!(
-    (prop.enum?.length && isObjectProperty(prop)) ||
+    prop.enum?.length ||
     prop.pattern ||
     prop.minimum != null ||
     prop.maximum != null ||
@@ -160,7 +169,8 @@ export function hasConstraints(prop: SpaProperty): boolean {
     prop.exclusiveMinimum != null ||
     prop.exclusiveMaximum != null ||
     prop.contentMediaType ||
-    prop.contentEncoding
+    prop.contentEncoding ||
+    prop.itemsRef
   )
 }
 

data/frontend/src/types.ts

@@ -25,6 +25,7 @@ export interface SpaProperty {
   minimum?: number
   maximum?: number
   itemsType?: string
+  itemsRef?: string
   deprecated?: boolean
   readOnly?: boolean
   writeOnly?: boolean
@@ -47,6 +48,20 @@ export interface SpaDefinition {
   title?: string
   description?: string
   type?: string
+  format?: string
+  enum?: string[]
+  const?: string
+  pattern?: string
+  default?: string
+  minLength?: number
+  maxLength?: number
+  minimum?: number
+  maximum?: number
+  exclusiveMinimum?: number
+  exclusiveMaximum?: number
+  multipleOf?: number
+  contentMediaType?: string
+  contentEncoding?: string
   properties: SpaProperty[]
   required: string[]
   examples?: string[]

data/lib/lutaml/jsonschema/spa/spa_builder.rb

@@ -163,6 +163,20 @@ module Lutaml
               title: s.title,
               description: s.description,
               type: s.type,
+              format: s.format,
+              enum: s.enum,
+              const_value: s.const,
+              pattern: s.pattern,
+              default: s.default,
+              min_length: s.min_length,
+              max_length: s.max_length,
+              minimum: s.minimum,
+              maximum: s.maximum,
+              exclusive_minimum: s.exclusive_minimum,
+              exclusive_maximum: s.exclusive_maximum,
+              multiple_of: s.multiple_of,
+              content_type: s.content_type,
+              content_encoding: s.content_encoding,
               properties: properties,
               required: all_required,
               examples: s.examples,
@@ -195,6 +209,7 @@ module Lutaml
           end
 
           prop_ref = resolve_prop_ref(entry.schema)
+          items_info = resolve_items_info(resolved, root_schema)
 
           SpaProperty.new(
             name: entry.name,
@@ -211,7 +226,8 @@ module Lutaml
             max_length: resolved.max_length,
             minimum: resolved.minimum,
             maximum: resolved.maximum,
-            items_type: resolved.items&.type,
+            items_type: items_info[:type],
+            items_ref: items_info[:ref],
             deprecated: resolved.deprecated,
             read_only: resolved.read_only,
             write_only: resolved.write_only,
@@ -230,6 +246,23 @@ module Lutaml
           )
         end
 
+        def resolve_items_info(resolved, root_schema)
+          items = resolved.items
+          return { type: nil, ref: nil } unless items
+
+          if items.dollar_ref
+            ref = items.dollar_ref
+            resolved_items = @schema_set.resolve_ref(ref, root_schema)
+            if resolved_items
+              { type: resolved_items.type || resolved_items.title, ref: ref }
+            else
+              { type: nil, ref: ref }
+            end
+          else
+            { type: items.type, ref: nil }
+          end
+        end
+
         def resolve_prop_ref(schema)
           return schema.dollar_ref if schema.dollar_ref
 

data/lib/lutaml/jsonschema/spa/spa_definition.rb

@@ -8,6 +8,20 @@ module Lutaml
         attribute :title, :string
         attribute :description, :string
         attribute :type, :string
+        attribute :format, :string
+        attribute :enum, :string, collection: true
+        attribute :const_value, :string
+        attribute :pattern, :string
+        attribute :default, :string
+        attribute :min_length, :integer
+        attribute :max_length, :integer
+        attribute :minimum, :float
+        attribute :maximum, :float
+        attribute :exclusive_minimum, :float
+        attribute :exclusive_maximum, :float
+        attribute :multiple_of, :float
+        attribute :content_type, :string
+        attribute :content_encoding, :string
         attribute :properties, SpaProperty, collection: true,
                                             initialize_empty: true
         attribute :required, :string, collection: true
@@ -24,6 +38,20 @@ module Lutaml
           map "title", to: :title
           map "description", to: :description
           map "type", to: :type
+          map "format", to: :format
+          map "enum", to: :enum
+          map "const", to: :const_value
+          map "pattern", to: :pattern
+          map "default", to: :default
+          map "minLength", to: :min_length
+          map "maxLength", to: :max_length
+          map "minimum", to: :minimum
+          map "maximum", to: :maximum
+          map "exclusiveMinimum", to: :exclusive_minimum
+          map "exclusiveMaximum", to: :exclusive_maximum
+          map "multipleOf", to: :multiple_of
+          map "contentMediaType", to: :content_type
+          map "contentEncoding", to: :content_encoding
           map "properties", to: :properties
           map "required", to: :required
           map "examples", to: :examples

data/lib/lutaml/jsonschema/spa/spa_property.rb

@@ -19,6 +19,7 @@ module Lutaml
         attribute :minimum, :float
         attribute :maximum, :float
         attribute :items_type, :string
+        attribute :items_ref, :string
         attribute :deprecated, :boolean
         attribute :read_only, :boolean
         attribute :write_only, :boolean
@@ -51,6 +52,7 @@ module Lutaml
           map "minimum", to: :minimum
           map "maximum", to: :maximum
           map "itemsType", to: :items_type
+          map "itemsRef", to: :items_ref
           map "deprecated", to: :deprecated
           map "readOnly", to: :read_only
           map "writeOnly", to: :write_only

data/lib/lutaml/jsonschema/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Jsonschema
-    VERSION = "0.1.16"
+    VERSION = "0.1.17"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-jsonschema
 version: !ruby/object:Gem::Version
-  version: 0.1.16
+  version: 0.1.17
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-14 00:00:00.000000000 Z
+date: 2026-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -95,6 +95,7 @@ files:
 - frontend/public/lutaml-logo-full-light.svg
 - frontend/public/lutaml-logo-light.svg
 - frontend/src/App.vue
+- frontend/src/__tests__/spaDataCompleteness.test.ts
 - frontend/src/__tests__/useBuilderField.test.ts
 - frontend/src/__tests__/useClipboard.test.ts
 - frontend/src/__tests__/useDefinitionResolver.test.ts