polen 0.10.0 → 0.11.0-next.2

package/src/template/routes/reference.tsx

@@ -2,16 +2,30 @@ import type { Content } from '#api/content/$'
 import { GrafaidOld } from '#lib/grafaid-old/index'
 import { createRoute } from '#lib/react-router-aid/react-router-aid'
 import { createLoader, useLoaderData } from '#lib/react-router-loader/react-router-loader'
+import { Box } from '@radix-ui/themes'
 import { Outlet } from 'react-router'
-import PROJECT_DATA from 'virtual:polen/project/data.jsonsuper'
 import { MissingSchema } from '../components/MissingSchema.js'
+import { VersionSelector } from '../components/VersionSelector.js'
+import { useVersionPath } from '../hooks/useVersionPath.js'
 import { SidebarLayout } from '../layouts/index.js'
+import { VERSION_LATEST } from '../lib/schema-utils/constants.js'
+import { schemaSource } from '../sources/schema-source.js'
 import { reference$type } from './reference.$type.js'
+import { referenceVersion$version$type } from './reference.version.$version.$type.js'
+
+const loader = createLoader(async ({ params }) => {
+  // Handle both versioned and unversioned routes:
+  // - Versioned: /reference/version/:version/:type → params.version exists
+  // - Unversioned: /reference/:type → params.version is undefined, defaults to latest
+  const currentVersion = params.version ?? VERSION_LATEST
+
+  const schema = await schemaSource.get(currentVersion)
+  const availableVersions = schemaSource.versions
 
-const loader = createLoader(() => {
-  const latestSchemaVersion = PROJECT_DATA.schema?.versions[0].after ?? null
   return {
-    schema: latestSchemaVersion,
+    schema,
+    currentVersion,
+    availableVersions,
   }
 })
 
@@ -28,6 +42,9 @@ const Component = () => {
   const sidebarItems: Content.Item[] = []
   const kindEntries = Object.entries(kindMap.list).filter(([_, types]) => types.length > 0)
 
+  // Build path prefix based on current version using new route structure
+  const versionPath = useVersionPath()
+
   for (const [title, types] of kindEntries) {
     sidebarItems.push({
       type: `ItemSection` as const,
@@ -37,21 +54,36 @@ const Component = () => {
       links: types.map(type => ({
         type: `ItemLink` as const,
         title: type.name,
-        pathExp: `reference/${type.name}`,
+        pathExp: `reference/${versionPath}${type.name}`,
       })),
     })
   }
 
   return (
     <SidebarLayout sidebar={sidebarItems}>
+      <Box mb={`4`}>
+        <VersionSelector
+          availableVersions={data.availableVersions}
+          currentVersion={data.currentVersion}
+        />
+      </Box>
       <Outlet />
     </SidebarLayout>
   )
 }
 
+// Create the versioned reference route with explicit version prefix
+const referenceVersioned = createRoute({
+  path: `version/:version`,
+  loader,
+  Component,
+  children: [referenceVersion$version$type],
+})
+
+// Create the main reference route with explicit version path and fallback type path
 export const reference = createRoute({
   path: `reference`,
   loader,
   Component,
-  children: [reference$type],
+  children: [referenceVersioned, reference$type],
 })

package/src/template/routes/reference.version.$version.$type.$field.tsx

@@ -0,0 +1,35 @@
+import { Grafaid } from '#lib/grafaid/index'
+import { createRoute } from '#lib/react-router-aid/react-router-aid'
+import { useLoaderData } from '#lib/react-router-loader/react-router-loader'
+import { useParams } from 'react-router'
+import { Field } from '../components/Field.js'
+import { MissingSchema } from '../components/MissingSchema.js'
+import type { reference } from './reference.js'
+
+const Component = () => {
+  const params = useParams() as { type: string; field: string; version: string }
+  const data = useLoaderData<typeof reference.loader>(`reference`)
+  if (!data.schema) {
+    return <MissingSchema />
+  }
+
+  const type = data.schema.getType(params.type)
+  if (!type) return `Could not find type ${params.type}`
+  if (!Grafaid.Schema.TypesLike.isFielded(type)) {
+    return `Type ${params.type} does not have fields`
+  }
+
+  const fields = type.getFields()
+  const field = fields[params.field]
+  if (!field) {
+    return `Could not find field ${params.field} on type ${params.type}`
+  }
+
+  return <Field data={field} />
+}
+
+export const referenceVersion$version$type$field = createRoute({
+  id: `reference-version-type-field`,
+  path: `:field`,
+  Component,
+})

package/src/template/routes/reference.version.$version.$type.tsx

@@ -0,0 +1,30 @@
+import { createRoute } from '#lib/react-router-aid/react-router-aid'
+import { useLoaderData } from '#lib/react-router-loader/react-router-loader'
+import { useParams } from 'react-router'
+import { MissingSchema } from '../components/MissingSchema.js'
+import { NamedType } from '../components/NamedType.js'
+import type { reference } from './reference.js'
+import { referenceVersion$version$type$field } from './reference.version.$version.$type.$field.js'
+
+const Component = () => {
+  const params = useParams() as { type: string; version: string }
+
+  const data = useLoaderData<typeof reference.loader>(`reference`)
+  if (!data.schema) {
+    return <MissingSchema />
+  }
+
+  const type = data.schema.getType(params.type)
+  if (!type) {
+    return <div>Type not found: {params.type}</div>
+  }
+
+  return <NamedType data={type} />
+}
+
+export const referenceVersion$version$type = createRoute({
+  id: `reference-version-type`,
+  path: `:type`,
+  Component,
+  children: [referenceVersion$version$type$field],
+})

package/src/template/routes/root.tsx

@@ -1,38 +1,12 @@
 import type { ReactRouter } from '#dep/react-router/index'
 import { createRoute } from '#lib/react-router-aid/react-router-aid'
-import { SidebarLayout } from '#template/layouts/index'
-import { MDXProvider } from '@mdx-js/react'
-import {
-  Badge,
-  Box,
-  Button,
-  Callout,
-  Card,
-  Code,
-  DataList,
-  Em,
-  Flex,
-  Heading,
-  Link,
-  Quote,
-  Separator,
-  Strong,
-  Table,
-  Tabs,
-  Text,
-  Theme,
-  Tooltip,
-} from '@radix-ui/themes'
-import { Link as LinkReactRouter, useLocation } from 'react-router'
+import { Box, Flex, Theme } from '@radix-ui/themes'
+import { Link as LinkReactRouter } from 'react-router'
 import { Outlet, ScrollRestoration } from 'react-router'
 import logoSrc from 'virtual:polen/project/assets/logo.svg'
 import PROJECT_DATA from 'virtual:polen/project/data.jsonsuper'
-import PROJECT_DATA_PAGES_CATALOG from 'virtual:polen/project/data/pages-catalog.jsonsuper'
-import { routes } from 'virtual:polen/project/routes.jsx'
+import PROJECT_SCHEMA from 'virtual:polen/project/schema.jsonsuper'
 import { templateVariables } from 'virtual:polen/template/variables'
-import { GraphQLSchemaProvider } from '../../lib/graphql-document/schema-context.js'
-import { CodeBlock } from '../components/CodeBlock.js'
-import { Pre } from '../components/CodeHikePre.js'
 import { Link as PolenLink } from '../components/Link.js'
 import { Logo } from '../components/Logo.js'
 import { NotFound } from '../components/NotFound.js'
@@ -40,22 +14,14 @@ import { ThemeToggle } from '../components/ThemeToggle.js'
 import { ThemeProvider, useTheme } from '../contexts/ThemeContext.js'
 import { changelog } from './changelog.js'
 import { index } from './index.js'
+import { pages } from './pages.js'
 import { reference } from './reference.js'
 
 export const Component = () => {
-  const schema = PROJECT_DATA.schema?.versions[0]?.after || null
-
-  // Make schema available globally for MDX components
-  if (typeof window !== `undefined` && schema) {
-    ;(window as any).__POLEN_GRAPHQL_SCHEMA__ = schema
-  }
-
   return (
     <>
       <ThemeProvider>
-        <GraphQLSchemaProvider schema={schema}>
-          <Layout />
-        </GraphQLSchemaProvider>
+        <Layout />
       </ThemeProvider>
       <ScrollRestoration />
     </>
@@ -105,82 +71,15 @@ const Layout = () => {
         py={{ initial: `4`, sm: `4`, md: `0` }}
       >
         {header}
-        <MDXProvider
-          components={{
-            // Map markdown elements to Radix with spacing
-            p: (props) => <Text as='p' mb='4' {...props} />,
-            h1: (props) => <Heading size='8' mt='6' mb='4' {...props} />,
-            h2: (props) => <Heading size='7' mt='6' mb='3' {...props} />,
-            h3: (props) => <Heading size='6' mt='5' mb='3' {...props} />,
-            h4: (props) => <Heading size='5' mt='5' mb='2' {...props} />,
-            h5: (props) => <Heading size='4' mt='4' mb='2' {...props} />,
-            h6: (props) => <Heading size='3' mt='4' mb='2' {...props} />,
-            strong: Strong,
-            em: Em,
-            code: Code,
-            blockquote: (props) => <Quote my='4' {...props} />,
-            a: Link,
-            hr: (props) => <Separator my='6' {...props} />,
-            pre: Pre,
-            table: Table.Root,
-            thead: Table.Header,
-            tbody: Table.Body,
-            tr: Table.Row,
-            th: Table.ColumnHeaderCell,
-            td: Table.Cell,
-            // Lists need spacing too
-            ul: (props) => <Box as='ul' mb='4' style={{ paddingLeft: '1.5rem' }} {...props} />,
-            ol: (props) => <Box as='ol' mb='4' style={{ paddingLeft: '1.5rem' }} {...props} />,
-            li: (props) => <Box as='li' mb='2' {...props} />,
-
-            // Direct Radix components for MDX
-            Badge,
-            Button,
-            // @ts-expect-error
-            Callout,
-            Card,
-            // @ts-expect-error
-            DataList,
-            // @ts-expect-error
-            Tabs,
-            Tooltip,
-
-            // Code Hike component
-            CodeBlock,
-          }}
-        >
-          <Outlet />
-        </MDXProvider>
+        <Outlet />
       </Box>
     </Theme>
   )
 }
 
-const PagesLayout = () => {
-  const location = useLocation() // Add this line
-
-  // Build sidebar from pages catalog
-  // Get the top-level path segment (e.g., '/guide/foo' -> '/guide')
-  const pathSegments = location.pathname.split('/').filter(Boolean)
-  const topLevelPath = pathSegments[0] ? `/${pathSegments[0]}` : '/'
-
-  // Get the sidebar for this section
-  const sidebar = PROJECT_DATA_PAGES_CATALOG.sidebarIndex[topLevelPath]?.items || []
-
-  return (
-    <SidebarLayout sidebar={sidebar}>
-      <Outlet />
-    </SidebarLayout>
-  )
-}
-
 const children: ReactRouter.RouteObject[] = [
   index,
-  {
-    // Pathless layout route - doesn't affect URL paths
-    Component: PagesLayout,
-    children: [...routes], // All MDX page routes go here
-  },
+  pages,
 ]
 
 //
@@ -192,7 +91,7 @@ const children: ReactRouter.RouteObject[] = [
 //
 //
 
-if (PROJECT_DATA.schema) {
+if (PROJECT_SCHEMA) {
   children.push(changelog)
   children.push(reference)
 }

package/src/template/server/app.ts

@@ -1,7 +1,6 @@
 import { Hono } from '#dep/hono/index'
 import { createHtmlTransformer, type HtmlTransformer } from '#lib/html-utils/html-transformer'
 import { serveStatic } from '@hono/node-server/serve-static'
-import PROJECT_DATA from 'virtual:polen/project/data.jsonsuper'
 import viteClientAssetManifest from 'virtual:polen/vite/client/manifest'
 import { injectManifestIntoHtml } from './manifest.js'
 import { PageMiddleware } from './middleware/page.js'
@@ -9,16 +8,60 @@ import { UnsupportedAssetsMiddleware } from './middleware/unsupported-assets.js'
 import { createPolenDataInjector } from './transformers/inject-polen-data.js'
 import { createThemeInitInjector } from './transformers/inject-theme-init.js'
 
+export type App = Hono.Hono
+
 export interface AppHooks {
   transformHtml?: HtmlTransformer[]
 }
 
 export interface AppOptions {
   hooks?: AppHooks
+  paths: {
+    base: string
+    assets: {
+      /**
+       * Directory path for serving static assets.
+       * MUST be a relative path from process.cwd() due to @hono/node-server constraints.
+       * Absolute paths are NOT supported by the serveStatic middleware.
+       *
+       * @example './node_modules/.vite/polen-assets'
+       * @example '../../../polen/node_modules/.vite/polen-assets'
+       * @example './dist/assets'
+       */
+      directory: string
+      /**
+       * URL route prefix for serving assets
+       * @example '/assets'
+       */
+      route: string
+    }
+  }
 }
 
-export const createApp = (options: AppOptions = {}) => {
-  const app = new Hono.Hono()
+export const createApp = (options: AppOptions) => {
+  const app = new Hono.Hono().basePath(options.paths.base)
+
+  // Static file serving
+  app.use(`*`, UnsupportedAssetsMiddleware())
+
+  const assetsRoutePattern = `${options.paths.assets.route}/*`
+
+  app.use(
+    assetsRoutePattern,
+    serveStatic({
+      root: options.paths.assets.directory,
+      rewriteRequestPath: (path) => {
+        // When basePath is set, the full path including base is passed here
+        // We need to strip both the base path and the assets route
+        const basePath = options.paths.base === '/' ? '' : options.paths.base
+        const fullPrefix = `${basePath}${options.paths.assets.route}`
+        return path.replace(new RegExp(`^${fullPrefix}`), '')
+      },
+      onNotFound(path) {
+        console.log('not found', path)
+      },
+    }),
+  )
 
   // Collect all HTML transformers
   const htmlTransformers: HtmlTransformer[] = [
@@ -29,21 +72,11 @@ export const createApp = (options: AppOptions = {}) => {
     ...(options.hooks?.transformHtml || []),
   ]
 
-  // Core middleware
-  app.use(`*`, UnsupportedAssetsMiddleware())
-
-  // Production-specific setup
   if (__BUILDING__) {
     // Add manifest transformer
     htmlTransformers.push(createHtmlTransformer((html, ___ctx) => {
-      return injectManifestIntoHtml(html, viteClientAssetManifest, PROJECT_DATA.basePath)
+      return injectManifestIntoHtml(html, viteClientAssetManifest, options.paths.base)
     }))
-
-    // Static file serving
-    app.use(
-      PROJECT_DATA.server.static.route,
-      serveStatic({ root: PROJECT_DATA.server.static.directory }),
-    )
   }
 
   app.all(`*`, PageMiddleware(htmlTransformers))

package/src/template/server/main.ts

@@ -12,7 +12,15 @@ if (__BUILDING__) {
       break
     case `ssr`:
       const port = process.env[`PORT`] ? parseInt(process.env[`PORT`]) : PROJECT_DATA.server.port
-      const app = createApp()
+      const app = createApp({
+        paths: {
+          assets: {
+            directory: PROJECT_DATA.paths.project.relative.build.relative.assets.root,
+            route: PROJECT_DATA.server.routes.assets,
+          },
+          base: PROJECT_DATA.basePath,
+        },
+      })
       serve({ fetch: app.fetch, port })
       break
     case `spa`:

package/src/template/server/ssg/generate.ts

@@ -14,7 +14,7 @@ import { getRoutesPaths } from './get-route-paths.js'
 export const generate = async (view: ReactRouter.StaticHandler) => {
   const debug = debugPolen.sub(`ssg`)
 
-  const routePaths = getRoutesPaths()
+  const routePaths = await getRoutesPaths()
   const totalPaths = routePaths.length
   debug(`start`, { totalPaths })
 
@@ -76,7 +76,7 @@ export const generate = async (view: ReactRouter.StaticHandler) => {
 
       const ssgResult = await Hono.SSG.toSSG(batchApp, NodeFs, {
         concurrency: 5, // Reduced concurrency for memory efficiency
-        dir: PROJECT_DATA.paths.relative.build.root,
+        dir: PROJECT_DATA.paths.project.relative.build.root,
       })
 
       if (!ssgResult.success) {

package/src/template/server/ssg/get-route-paths.ts

@@ -1,7 +1,8 @@
-import { Grafaid } from '#lib/grafaid/index'
-import { visit } from 'graphql'
-// Or your specific import path for this type
+import { Api } from '#api/index'
 import { ReactRouterAid } from '#lib/react-router-aid/index'
+import { visit } from 'graphql'
+import * as NodeFs from 'node:fs/promises'
+import * as NodePath from 'node:path'
 import PROJECT_DATA from 'virtual:polen/project/data.jsonsuper'
 import { routes } from '../../routes.js'
 
@@ -10,37 +11,62 @@ import { routes } from '../../routes.js'
 // Maybe we can figure something out too.
 const knownParameterizedRouteExpressions = {
   reference_type: `/reference/:type`,
+  reference_versioned_type: `/reference/version/:version/:type`,
 }
 
-export const getRoutesPaths = (): string[] => {
+export const getRoutesPaths = async (): Promise<string[]> => {
   const paths = new Set<string>()
   const routeExpressions = ReactRouterAid.getRouteExpressions(routes)
 
+  // Helper function to load schema from filesystem and add type paths
+  const addTypePathsForVersion = async (version: string, pathPrefix: string) => {
+    try {
+      const schemaFilePath = NodePath.join(PROJECT_DATA.paths.project.absolute.build.assets.schemas, `${version}.json`)
+      const schemaContent = await NodeFs.readFile(schemaFilePath, 'utf-8')
+      const schemaAst = JSON.parse(schemaContent)
+
+      visit(schemaAst, {
+        ObjectTypeDefinition(node) {
+          paths.add(`${pathPrefix}/${node.name.value}`)
+        },
+        InterfaceTypeDefinition(node) {
+          paths.add(`${pathPrefix}/${node.name.value}`)
+        },
+        EnumTypeDefinition(node) {
+          paths.add(`${pathPrefix}/${node.name.value}`)
+        },
+        InputObjectTypeDefinition(node) {
+          paths.add(`${pathPrefix}/${node.name.value}`)
+        },
+        UnionTypeDefinition(node) {
+          paths.add(`${pathPrefix}/${node.name.value}`)
+        },
+        ScalarTypeDefinition(node) {
+          paths.add(`${pathPrefix}/${node.name.value}`)
+        },
+      })
+    } catch (error) {
+      throw new Error(`SSG failed to load schema for version ${version}. Ensure schema assets are built. ${error}`)
+    }
+  }
+
+  const schemaMetadataPath = NodePath.join(PROJECT_DATA.paths.project.absolute.build.assets.schemas, 'metadata.json')
+
+  const schemaMetadata = await Api.Schema.getMetadata(schemaMetadataPath)
+  const { hasSchema, versions: availableVersions } = schemaMetadata
+
   for (const exp of routeExpressions) {
     if (exp === knownParameterizedRouteExpressions.reference_type) {
-      if (PROJECT_DATA.schema) {
-        const schema = PROJECT_DATA.schema.versions[0].after
-        const ast = Grafaid.Schema.AST.parse(Grafaid.Schema.print(schema))
-        visit(ast, {
-          ObjectTypeDefinition(node) {
-            paths.add(`/reference/${node.name.value}`)
-          },
-          InterfaceTypeDefinition(node) {
-            paths.add(`/reference/${node.name.value}`)
-          },
-          EnumTypeDefinition(node) {
-            paths.add(`/reference/${node.name.value}`)
-          },
-          InputObjectTypeDefinition(node) {
-            paths.add(`/reference/${node.name.value}`)
-          },
-          UnionTypeDefinition(node) {
-            paths.add(`/reference/${node.name.value}`)
-          },
-          ScalarTypeDefinition(node) {
-            paths.add(`/reference/${node.name.value}`)
-          },
-        })
+      if (hasSchema) {
+        // Add paths for latest version (no version in URL)
+        await addTypePathsForVersion(Api.Schema.VERSION_LATEST, `/reference`)
+      }
+    } else if (exp === knownParameterizedRouteExpressions.reference_versioned_type) {
+      if (hasSchema) {
+        // Add paths for all versions using new route structure
+        for (const version of availableVersions) {
+          await addTypePathsForVersion(version, `/reference/version/${version}`)
+        }
       }
     } else if (ReactRouterAid.isParameterizedPath(exp)) {
       throw new Error(`Unhandled parameterized path: ${exp}`)

package/src/template/sources/schema-source.ts

@@ -0,0 +1,68 @@
+import PROJECT_DATA from 'virtual:polen/project/data.jsonsuper'
+import PROJECT_SCHEMA_METADATA from 'virtual:polen/project/schema-metadata'
+import { createSchemaSource } from '../../api/schema-source/index.js'
+import { polenUrlPathAssets } from '../lib/polen-url.js'
+
+// Environment-specific IO implementation
+const io = import.meta.env.SSR
+  ? {
+    // Server-side: Read from filesystem
+    read: async (path: string) => {
+      // Dynamic import to keep fs out of client bundle
+      const { readFile } = await import('node:fs/promises')
+
+      // Extract the path after the assets route
+      // e.g., "/assets/schemas/latest.json" -> "schemas/latest.json"
+      const assetsRoute = PROJECT_DATA.server.routes.assets
+      const routePattern = new RegExp(`^${assetsRoute}/(.+)$`)
+      const match = path.match(routePattern)
+      const assetPath = match ? match[1] : path
+
+      // In SSR, we need to read from the correct location
+      // During dev, assets are served from Polen's node_modules
+      // In production, they're in the build output directory
+      let fullPath: string
+      if (import.meta.env.DEV) {
+        // Development: Read from Polen's Vite cache
+        fullPath = `${PROJECT_DATA.paths.framework.devAssets.absolute}/${assetPath}`
+      } else {
+        // Production: Read from build output
+        // The server runs from the project root, and assets are in build/assets/
+        fullPath =
+          `${PROJECT_DATA.paths.project.relative.build.root}/${PROJECT_DATA.paths.project.relative.build.relative.assets.root}/${assetPath}`
+      }
+
+      return readFile(fullPath, 'utf-8')
+    },
+  }
+  : {
+    // Client-side: Fetch from HTTP
+    read: async (path: string) => {
+      const response = await fetch(path)
+      if (!response.ok) {
+        throw new Error(`Failed to fetch: ${path} (${response.status} ${response.statusText})`)
+      }
+      return response.text()
+    },
+  }
+
+// Create and export the source object directly
+export const schemaSource = createSchemaSource({
+  io,
+  versions: PROJECT_SCHEMA_METADATA.versions,
+  assetsPath: polenUrlPathAssets(),
+})
+
+// HMR cache invalidation for development
+if (import.meta.hot) {
+  import.meta.hot.on('polen:schema-invalidate', () => {
+    console.log('[HMR] Schema cache invalidated')
+    schemaSource.clearCache()
+
+    // Brute force approach: reload the page to ensure fresh data
+    // This guarantees all components see the updated schema immediately
+    // TODO: When we have reactive data fetching, remove this reload
+    //       and let the reactive system handle updates gracefully
+    window.location.reload()
+  })
+}

package/build/lib/graphql-document/$$.d.ts

@@ -1,5 +0,0 @@
-export * from './analysis.js';
-export * from './positioning-simple.js';
-export * from './schema-integration.js';
-export * from './types.js';
-//# sourceMappingURL=$$.d.ts.map

package/build/lib/graphql-document/$$.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"$$.d.ts","sourceRoot":"","sources":["../../../src/lib/graphql-document/$$.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,yBAAyB,CAAA;AACvC,cAAc,yBAAyB,CAAA;AACvC,cAAc,YAAY,CAAA"}

package/build/lib/graphql-document/$$.js

@@ -1,5 +0,0 @@
-export * from './analysis.js';
-export * from './positioning-simple.js';
-export * from './schema-integration.js';
-export * from './types.js';
-//# sourceMappingURL=$$.js.map

package/build/lib/graphql-document/$$.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"$$.js","sourceRoot":"","sources":["../../../src/lib/graphql-document/$$.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,yBAAyB,CAAA;AACvC,cAAc,yBAAyB,CAAA;AACvC,cAAc,YAAY,CAAA"}

package/build/lib/graphql-document/$.d.ts

@@ -1,2 +0,0 @@
-export * as GraphQLDocument from './graphql-document.js';
-//# sourceMappingURL=$.d.ts.map

package/build/lib/graphql-document/$.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"$.d.ts","sourceRoot":"","sources":["../../../src/lib/graphql-document/$.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,eAAe,MAAM,uBAAuB,CAAA"}

package/build/lib/graphql-document/$.js

@@ -1,2 +0,0 @@
-export * as GraphQLDocument from './graphql-document.js';
-//# sourceMappingURL=$.js.map

package/build/lib/graphql-document/$.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"$.js","sourceRoot":"","sources":["../../../src/lib/graphql-document/$.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,eAAe,MAAM,uBAAuB,CAAA"}