polen 0.11.0-next.11 → 0.11.0-next.13

package/src/lib/schema-lifecycle/handlers.ts

@@ -0,0 +1,215 @@
+import { Grafaid } from '#lib/grafaid'
+import type { GraphqlChange } from '#lib/graphql-change'
+import type { GraphqlChangeset } from '#lib/graphql-changeset'
+import { GraphQLPath } from '#lib/graphql-path/$'
+import type { NonEmptyArray } from '#lib/kit-temp'
+import { type GraphQLNamedType, isInputObjectType, isInterfaceType, isNamedType, isObjectType } from 'graphql'
+import type { AddedEvent, LifecycleEventBase, RemovedEvent } from './LifecycleEvent.js'
+import type { NamedTypeLifecycle } from './NamedTypeLifecycle.js'
+import { createNamedTypeLifecycle } from './NamedTypeLifecycle.js'
+
+/**
+ * Populate fields for a type that has fields (Object, Interface, or InputObject types)
+ */
+const populateTypeFields = (
+  typeLifecycle: NamedTypeLifecycle,
+  graphqlType: GraphQLNamedType,
+  date: Date,
+  changeSet: GraphqlChangeset.ChangeSet | null,
+  schema: GraphqlChangeset.VersionableSchema,
+) => {
+  if (isObjectType(graphqlType) || isInterfaceType(graphqlType) || isInputObjectType(graphqlType)) {
+    const fields = graphqlType.getFields()
+    const typeWithFields = typeLifecycle as any
+
+    if (typeWithFields.fields) {
+      for (const [fieldName] of Object.entries(fields)) {
+        const fieldAddedEvent: AddedEvent = {
+          type: 'added',
+          date,
+          changeSet,
+          schema,
+        }
+
+        typeWithFields.fields[fieldName] = {
+          name: fieldName,
+          events: [fieldAddedEvent] as NonEmptyArray<LifecycleEventBase>,
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Handle field changes (add/remove) for both regular fields and input fields
+ */
+const handleFieldChange = (
+  data: Record<string, NamedTypeLifecycle>,
+  change: GraphqlChange.Group.FieldOperation | GraphqlChange.Group.InputFieldOperation,
+  changeSet: GraphqlChangeset.IntermediateChangeSetLinked,
+  isInputField: boolean,
+) => {
+  const addType = isInputField ? 'INPUT_FIELD_ADDED' : 'FIELD_ADDED'
+  const removeType = isInputField ? 'INPUT_FIELD_REMOVED' : 'FIELD_REMOVED'
+
+  if (change.type === addType) {
+    const { typeName, fieldName } = GraphQLPath.Definition.parseFieldPath(change.path)
+    if (!typeName || !fieldName) return
+
+    const addedEvent: AddedEvent = {
+      type: 'added',
+      date: changeSet.date,
+      changeSet: changeSet,
+      schema: changeSet.after,
+    }
+
+    // Ensure type exists
+    if (!data[typeName]) {
+      const graphqlType = changeSet.after.data.getType(typeName)
+      if (!graphqlType || !isNamedType(graphqlType)) {
+        throw new Error(`Type ${typeName} not found in schema`)
+      }
+
+      const kind = Grafaid.Schema.typeKindFromClass(graphqlType)
+      const typeEvent: AddedEvent = {
+        type: 'added',
+        date: new Date('1970-01-01'), // Unknown when type was added
+        changeSet: null,
+        schema: { version: null, data: null },
+      }
+      data[typeName] = createNamedTypeLifecycle(typeName, kind, typeEvent)
+    }
+
+    const typeLifecycle = data[typeName]
+    if ('fields' in typeLifecycle) {
+      typeLifecycle.fields[fieldName] = {
+        name: fieldName,
+        events: [addedEvent],
+      }
+    }
+  } else if (change.type === removeType) {
+    const { typeName, fieldName } = GraphQLPath.Definition.parseFieldPath(change.path)
+    if (!typeName || !fieldName) return
+
+    const removedEvent: RemovedEvent = {
+      type: 'removed',
+      date: changeSet.date,
+      changeSet: changeSet,
+      schema: changeSet.after,
+    }
+
+    const typeLifecycle = data[typeName]
+    if (typeLifecycle && 'fields' in typeLifecycle && typeLifecycle.fields[fieldName]) {
+      typeLifecycle.fields[fieldName].events = [
+        removedEvent,
+        ...typeLifecycle.fields[fieldName].events,
+      ] as NonEmptyArray<any>
+    }
+  }
+  // TODO: Handle FIELD_TYPE_CHANGED / INPUT_FIELD_TYPE_CHANGED
+}
+
+/**
+ * Create lifecycle entries for all types in an initial schema (treat as "create events")
+ */
+export const createInitialTypeLifecycles = (
+  data: Record<string, NamedTypeLifecycle>,
+  changeSet: GraphqlChangeset.InitialChangeSetLinked,
+) => {
+  const typeMap = changeSet.after.data.getTypeMap()
+
+  for (const [typeName, graphqlType] of Object.entries(typeMap)) {
+    // Skip built-in types that start with __
+    if (typeName.startsWith('__')) continue
+
+    if (!isNamedType(graphqlType)) continue
+
+    const addedEvent: AddedEvent = {
+      type: 'added',
+      date: changeSet.date,
+      changeSet: changeSet,
+      schema: changeSet.after,
+    }
+
+    const kind = Grafaid.Schema.typeKindFromClass(graphqlType)
+    const typeLifecycle = createNamedTypeLifecycle(typeName, kind, addedEvent)
+    data[typeName] = typeLifecycle
+
+    // Populate fields for types that have them
+    populateTypeFields(typeLifecycle, graphqlType, changeSet.date, changeSet, changeSet.after)
+  }
+}
+
+/**
+ * Handler for type operations (TYPE_ADDED, TYPE_REMOVED, TYPE_KIND_CHANGED)
+ */
+export const TypeOperation = (
+  data: Record<string, NamedTypeLifecycle>,
+  change: GraphqlChange.Group.TypeOperation,
+  changeSet: GraphqlChangeset.IntermediateChangeSetLinked,
+) => {
+  if (change.type === 'TYPE_ADDED') {
+    const typeName = change.path || change.message || 'Unknown'
+    if (!typeName) return
+
+    const addedEvent: AddedEvent = {
+      type: 'added',
+      date: changeSet.date,
+      changeSet: changeSet,
+      schema: changeSet.after,
+    }
+
+    // Get actual type from schema to determine kind
+    const graphqlType = changeSet.after.data.getType(typeName)
+    if (!graphqlType || !isNamedType(graphqlType)) {
+      throw new Error(`Type ${typeName} not found in schema`)
+    }
+
+    const kind = Grafaid.Schema.typeKindFromClass(graphqlType)
+    const typeLifecycle = createNamedTypeLifecycle(typeName, kind, addedEvent)
+    data[typeName] = typeLifecycle
+
+    // Populate fields for types that have them
+    populateTypeFields(typeLifecycle, graphqlType, changeSet.date, changeSet, changeSet.after)
+  } else if (change.type === 'TYPE_REMOVED') {
+    const typeName = change.path || change.message || 'Unknown'
+    if (!typeName) return
+
+    const removedEvent: RemovedEvent = {
+      type: 'removed',
+      date: changeSet.date,
+      changeSet: changeSet,
+      schema: changeSet.after,
+    }
+
+    // Add removal event to existing type
+    if (data[typeName]) {
+      data[typeName].events = [removedEvent, ...data[typeName].events] as NonEmptyArray<any>
+    }
+  } else if (change.type === 'TYPE_KIND_CHANGED') {
+    // TODO: Handle type kind changes
+    // This would update the kind property of an existing type
+  }
+}
+
+/**
+ * Handler for field operations (FIELD_ADDED, FIELD_REMOVED, FIELD_TYPE_CHANGED)
+ */
+export const FieldOperation = (
+  data: Record<string, NamedTypeLifecycle>,
+  change: GraphqlChange.Group.FieldOperation,
+  changeSet: GraphqlChangeset.IntermediateChangeSetLinked,
+) => {
+  handleFieldChange(data, change, changeSet, false)
+}
+
+/**
+ * Handler for input field operations (INPUT_FIELD_ADDED, INPUT_FIELD_REMOVED, INPUT_FIELD_TYPE_CHANGED)
+ */
+export const InputFieldOperation = (
+  data: Record<string, NamedTypeLifecycle>,
+  change: GraphqlChange.Group.InputFieldOperation,
+  changeSet: GraphqlChangeset.IntermediateChangeSetLinked,
+) => {
+  handleFieldChange(data, change, changeSet, true)
+}

package/src/lib/schema-lifecycle/utils.ts

@@ -0,0 +1,234 @@
+import { GraphQLPath } from '#lib/graphql-path'
+import type { FieldLifecycle, InputFieldLifecycle } from './FieldLifecycle.js'
+import type { AddedEvent, RemovedEvent } from './LifecycleEvent.js'
+import type { NamedTypeLifecycle } from './NamedTypeLifecycle.js'
+import type { SchemaLifecycle } from './SchemaLifecycle.js'
+
+/**
+ * Get lifecycle data for a specific type
+ */
+export const getTypeLifecycle = (
+  lifecycle: SchemaLifecycle,
+  typeName: string,
+): NamedTypeLifecycle | null => {
+  return lifecycle.data[typeName] || null
+}
+
+/**
+ * Get lifecycle data for a specific field
+ */
+export const getFieldLifecycle = (
+  lifecycle: SchemaLifecycle,
+  path: GraphQLPath.Definition.FieldDefinitionPath,
+): FieldLifecycle | InputFieldLifecycle | null => {
+  const typeName = GraphQLPath.Definition.getType(path)
+  const fieldName = GraphQLPath.Definition.getField(path)
+
+  const typeLifecycle = getTypeLifecycle(lifecycle, typeName)
+  if (!typeLifecycle) return null
+
+  if ('fields' in typeLifecycle) {
+    return typeLifecycle.fields[fieldName] || null
+  }
+
+  return null
+}
+
+/**
+ * Check if a type is currently available (not removed)
+ */
+export const isTypeCurrentlyAvailable = (
+  lifecycle: SchemaLifecycle,
+  typeName: string,
+): boolean => {
+  const typeLifecycle = getTypeLifecycle(lifecycle, typeName)
+  if (!typeLifecycle) return false
+
+  const mostRecentEvent = typeLifecycle.events[0]
+  return (mostRecentEvent as AddedEvent | RemovedEvent).type === 'added'
+}
+
+/**
+ * Check if a field is currently available (not removed)
+ */
+export const isFieldCurrentlyAvailable = (
+  lifecycle: SchemaLifecycle,
+  path: GraphQLPath.Definition.FieldDefinitionPath,
+): boolean => {
+  const fieldLifecycle = getFieldLifecycle(lifecycle, path)
+  if (!fieldLifecycle) return false
+
+  const mostRecentEvent = fieldLifecycle.events[0]
+  return (mostRecentEvent as AddedEvent | RemovedEvent).type === 'added'
+}
+
+/**
+ * Get the date when a type was first added
+ */
+export const getTypeAddedDate = (
+  lifecycle: SchemaLifecycle,
+  typeName: string,
+): Date | null => {
+  const typeLifecycle = getTypeLifecycle(lifecycle, typeName)
+  if (!typeLifecycle) return null
+
+  // Find the first (oldest) added event
+  const addedEvents = typeLifecycle.events.filter(
+    (event): event is AddedEvent => (event as AddedEvent | RemovedEvent).type === 'added',
+  )
+
+  if (addedEvents.length === 0) return null
+
+  // Events are in reverse chronological order, so last item is oldest
+  return addedEvents[addedEvents.length - 1]?.date || null
+}
+
+/**
+ * Get the date when a type was most recently removed (if any)
+ */
+export const getTypeRemovedDate = (
+  lifecycle: SchemaLifecycle,
+  typeName: string,
+): Date | null => {
+  const typeLifecycle = getTypeLifecycle(lifecycle, typeName)
+  if (!typeLifecycle) return null
+
+  // Find the most recent removed event
+  const removedEvent = typeLifecycle.events.find(
+    (event): event is RemovedEvent => (event as AddedEvent | RemovedEvent).type === 'removed',
+  )
+
+  return removedEvent?.date || null
+}
+
+/**
+ * Get the date when a field was first added
+ */
+export const getFieldAddedDate = (
+  lifecycle: SchemaLifecycle,
+  path: GraphQLPath.Definition.FieldDefinitionPath,
+): Date | null => {
+  const fieldLifecycle = getFieldLifecycle(lifecycle, path)
+  if (!fieldLifecycle) return null
+
+  // Find the first (oldest) added event
+  const addedEvents = fieldLifecycle.events.filter(
+    (event): event is AddedEvent => (event as AddedEvent | RemovedEvent).type === 'added',
+  )
+
+  if (addedEvents.length === 0) return null
+
+  // Events are in reverse chronological order, so last item is oldest
+  return addedEvents[addedEvents.length - 1]?.date || null
+}
+
+/**
+ * Get the date when a field was most recently removed (if any)
+ */
+export const getFieldRemovedDate = (
+  lifecycle: SchemaLifecycle,
+  path: GraphQLPath.Definition.FieldDefinitionPath,
+): Date | null => {
+  const fieldLifecycle = getFieldLifecycle(lifecycle, path)
+  if (!fieldLifecycle) return null
+
+  // Find the most recent removed event
+  const removedEvent = fieldLifecycle.events.find(
+    (event): event is RemovedEvent => (event as AddedEvent | RemovedEvent).type === 'removed',
+  )
+
+  return removedEvent?.date || null
+}
+
+/**
+ * Get all types that were added on a specific date
+ */
+export const getTypesAddedOnDate = (
+  lifecycle: SchemaLifecycle,
+  date: Date,
+): string[] => {
+  const result: string[] = []
+
+  for (const [typeName, typeLifecycle] of Object.entries(lifecycle.data)) {
+    const addedOnDate = typeLifecycle.events.some(
+      event => (event as AddedEvent | RemovedEvent).type === 'added' && event.date.getTime() === date.getTime(),
+    )
+
+    if (addedOnDate) {
+      result.push(typeName)
+    }
+  }
+
+  return result
+}
+
+/**
+ * Get all types that were removed on a specific date
+ */
+export const getTypesRemovedOnDate = (
+  lifecycle: SchemaLifecycle,
+  date: Date,
+): string[] => {
+  const result: string[] = []
+
+  for (const [typeName, typeLifecycle] of Object.entries(lifecycle.data)) {
+    const removedOnDate = typeLifecycle.events.some(
+      event => (event as AddedEvent | RemovedEvent).type === 'removed' && event.date.getTime() === date.getTime(),
+    )
+
+    if (removedOnDate) {
+      result.push(typeName)
+    }
+  }
+
+  return result
+}
+
+/**
+ * Get a human-readable description of a type's lifecycle status
+ */
+export const getTypeLifecycleDescription = (
+  lifecycle: SchemaLifecycle,
+  typeName: string,
+): string => {
+  const typeLifecycle = getTypeLifecycle(lifecycle, typeName)
+  if (!typeLifecycle) return `Type "${typeName}" not found`
+
+  const isAvailable = isTypeCurrentlyAvailable(lifecycle, typeName)
+  const addedDate = getTypeAddedDate(lifecycle, typeName)
+  const removedDate = getTypeRemovedDate(lifecycle, typeName)
+
+  if (isAvailable) {
+    return `Available since ${addedDate?.toISOString().split('T')[0] || 'unknown'}`
+  } else if (removedDate) {
+    return `Removed on ${removedDate.toISOString().split('T')[0]}`
+  } else {
+    return 'Status unknown'
+  }
+}
+
+/**
+ * Get a human-readable description of a field's lifecycle status
+ */
+export const getFieldLifecycleDescription = (
+  lifecycle: SchemaLifecycle,
+  path: GraphQLPath.Definition.FieldDefinitionPath,
+): string => {
+  const typeName = GraphQLPath.Definition.getType(path)
+  const fieldName = GraphQLPath.Definition.getField(path)
+
+  const fieldLifecycle = getFieldLifecycle(lifecycle, path)
+  if (!fieldLifecycle) return `Field "${typeName}.${fieldName}" not found`
+
+  const isAvailable = isFieldCurrentlyAvailable(lifecycle, path)
+  const addedDate = getFieldAddedDate(lifecycle, path)
+  const removedDate = getFieldRemovedDate(lifecycle, path)
+
+  if (isAvailable) {
+    return `Available since ${addedDate?.toISOString().split('T')[0] || 'unknown'}`
+  } else if (removedDate) {
+    return `Removed on ${removedDate.toISOString().split('T')[0]}`
+  } else {
+    return 'Status unknown'
+  }
+}

package/src/lib/superjson-codec/$.ts

@@ -0,0 +1 @@
+export * as SuperjsonCodecs from './$$.js'

package/src/lib/superjson-codec/codecs/graphql-schema.ts

@@ -1,4 +1,4 @@
-import { Grafaid } from '#lib/grafaid/index'
+import { Grafaid } from '#lib/grafaid'
 import { create } from '../codec.js'
 
 export const GraphQLSchema = create({

package/src/lib/theme/$$.ts

@@ -0,0 +1 @@
+export * from './theme.js'

package/src/lib/theme/$.ts

@@ -1,2 +1,2 @@
 // Namespace export
-export * as Theme from './theme.js'
+export * as Theme from './$$.js'

package/src/lib/vite-plugin-config/$.ts

@@ -0,0 +1 @@
+export * as VitePluginConfig from './$$.js'

package/src/lib/vite-plugin-reactive-data/vite-plugin-reactive-data.ts

@@ -1,4 +1,4 @@
-import type { VitePluginJson } from '#lib/vite-plugin-json/index'
+import type { VitePluginJson } from '#lib/vite-plugin-json'
 import { debugPolen } from '#singletons/debug'
 import { type ComputedRef, effect, isRef } from '@vue/reactivity'
 import type { Plugin, ViteDevServer } from 'vite'

package/src/lib/vite-plugins/$.ts

@@ -0,0 +1,4 @@
+/**
+ * Export unified VitePlugins namespace
+ */
+export * as VitePlugins from './$$.js'

package/src/lib/vite-virtual/$.ts

@@ -0,0 +1 @@
+export * as ViteVirtual from './$$.js'

package/src/lib/vite-virtual/identified-loader.ts

@@ -1,5 +1,5 @@
 import type { Vite } from '#dep/vite/index'
-import { StackProcessor } from '../stack-processor/index.js'
+import { StackProcessor } from '#lib/stack-processor'
 import { debug } from './debug.js'
 import type { HookLoad, HookResolveId } from './hooks.js'
 import type { Identifier } from './identifier.js'

package/src/sandbox.ts

@@ -1,43 +1 @@
-import { buildSchema } from 'graphql'
-import { parseGraphQLWithTreeSitter } from './template/components/GraphQLInteractive/lib/parser.js'
-
-const schema = buildSchema(`
-  type Pokemon {
-    id: ID!
-    name: String!
-    types: [PokemonType!]!
-    abilities: [Ability!]!
-  }
-  
-  type Ability {
-    name: String!
-    description: String!
-  }
-  
-  enum PokemonType {
-    FIRE
-    WATER
-    GRASS
-    ELECTRIC
-    PSYCHIC
-  }
-  
-  type Query {
-    pokemon(id: ID!): Pokemon
-  }
-`)
-
-const code = `query GetPokemon($id: ID!) {
-  pokemon(id: $id) {
-    id
-    name
-  }
-}`
-
-console.log('Testing GraphQL parser...')
-const tokens = await parseGraphQLWithTreeSitter(code, [], schema)
-console.log('\nTotal tokens:', tokens.length)
-console.log('\nInteractive tokens:')
-tokens.filter(t => t.polen.isInteractive()).forEach(t => {
-  console.log(`- "${t.text}" (${t.highlighter.getCssClass()}) -> ${t.polen.getReferenceUrl()}`)
-})
+// Temporary sandbox file for testing

package/src/singletons/superjson.ts

@@ -1,5 +1,5 @@
 import { Superjson } from '#dep/superjson/index'
-import { SuperjsonCodecs } from '#lib/superjson-codec/index'
+import { SuperjsonCodecs } from '#lib/superjson-codec'
 
 const superjson = new Superjson.SuperJSON()
 

package/src/template/components/ArgumentList.tsx

@@ -1,13 +1,9 @@
+import type { React } from '#dep/react/index'
 import { Box, Flex, Heading, Text } from '@radix-ui/themes'
 import type { GraphQLArgument } from 'graphql'
-import type { FC } from 'react'
 import { TypeAnnotation } from './TypeAnnotation.js'
 
-export interface Props {
-  args: readonly GraphQLArgument[]
-}
-
-export const ArgumentsList: FC<Props> = ({ args }) => {
+export const ArgumentsList: React.FC<{ args: readonly GraphQLArgument[] }> = ({ args }) => {
   if (args.length === 0) return null
 
   return (

package/src/template/components/ArgumentListAnnotation.tsx

@@ -1,4 +1,4 @@
-import { GrafaidOld } from '#lib/grafaid-old/index'
+import { GrafaidOld } from '#lib/grafaid-old'
 import { Box, Text } from '@radix-ui/themes'
 import type { GraphQLField } from 'graphql'
 import type { FC } from 'react'

package/src/template/components/Changelog/ChangeBase.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import type React from 'react'
 
 interface ChangeBaseProps {

package/src/template/components/Changelog/CriticalitySection.tsx

@@ -1,5 +1,5 @@
+import type { GraphqlChange } from '#lib/graphql-change'
 import { CRITICALITY_CONFIG, type CriticalityLevel } from '#lib/graphql-change/criticality'
-import type { GraphqlChange } from '#lib/graphql-change/index'
 import { Heading } from '@radix-ui/themes'
 import type React from 'react'
 

package/src/template/components/Changelog/groups/DirectiveArgument.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'

package/src/template/components/Changelog/groups/DirectiveArgumentDescription.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'

package/src/template/components/Changelog/groups/DirectiveArgumentOperation.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'

package/src/template/components/Changelog/groups/DirectiveDescription.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'

package/src/template/components/Changelog/groups/DirectiveLocationOperation.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'

package/src/template/components/Changelog/groups/DirectiveOperation.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'

package/src/template/components/Changelog/groups/DirectiveUsage.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'

package/src/template/components/Changelog/groups/EnumValueDeprecationReason.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'

package/src/template/components/Changelog/groups/EnumValueDescription.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'

package/src/template/components/Changelog/groups/EnumValueOperation.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'

package/src/template/components/Changelog/groups/FieldArgument.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'

package/src/template/components/Changelog/groups/FieldArgumentDescription.tsx

@@ -1,4 +1,4 @@
-import type { GraphqlChange } from '#lib/graphql-change/index'
+import type { GraphqlChange } from '#lib/graphql-change'
 import { Code } from '@radix-ui/themes'
 import type React from 'react'
 import { ChangeBase } from '../ChangeBase.js'