@eclipsa/content 0.0.0

package/types.ts

@@ -0,0 +1,172 @@
+import type { InferStandardSchemaOutput, StandardSchemaV1 } from 'eclipsa'
+
+export const CONTENT_COLLECTION_MARKER = '__eclipsa_content_collection__'
+
+export interface ContentSourceEntry {
+  body: string
+  data?: Record<string, unknown>
+  filePath?: string
+  id?: string
+}
+
+export interface ContentLoaderContext {
+  collection: string
+  configPath: string
+  root: string
+}
+
+export interface ContentLoaderObject {
+  load(
+    context: ContentLoaderContext,
+  ): ContentSourceEntry[] | Promise<ContentSourceEntry[]> | readonly ContentSourceEntry[]
+}
+
+export interface ContentHighlightOptions {
+  theme?: string
+}
+
+export interface ContentMarkdownOptions {
+  highlight?: boolean | ContentHighlightOptions
+}
+
+export interface ContentSearchOptions {
+  enabled?: boolean
+  hotkey?: string
+  limit?: number
+  placeholder?: string
+  prefix?: boolean
+}
+
+export interface ResolvedContentSearchOptions {
+  enabled: boolean
+  hotkey: string
+  limit: number
+  placeholder: string
+  prefix: boolean
+}
+
+export type ContentSearchField = 'body' | 'code' | 'heading' | 'title'
+
+export interface ContentSearchDocument {
+  body: string
+  code: string[]
+  collection: string
+  headings: string[]
+  id: string
+  title: string
+  url: string
+}
+
+export interface ContentSearchPosting {
+  docIdx: number
+  field: ContentSearchField
+  tf: number
+}
+
+export interface ContentSearchIndex {
+  avgDl: number
+  df: Record<string, number>
+  docCount: number
+  documents: ContentSearchDocument[]
+  index: Record<string, ContentSearchPosting[]>
+  options: ResolvedContentSearchOptions
+}
+
+export interface ContentSearchQueryOptions {
+  limit?: number
+  prefix?: boolean
+}
+
+export interface ContentSearchResult {
+  collection: string
+  id: string
+  matches: string[]
+  score: number
+  snippet: string
+  title: string
+  url: string
+}
+
+export interface GlobLoaderOptions {
+  base: string
+  pattern: string
+}
+
+export interface GlobLoader {
+  readonly base: string
+  readonly kind: 'glob'
+  readonly pattern: string
+}
+
+export type ContentLoader = GlobLoader | ContentLoaderObject
+
+export interface ContentCollectionDefinition<
+  Schema extends StandardSchemaV1<any, any> | undefined,
+> {
+  loader: ContentLoader
+  markdown?: ContentMarkdownOptions
+  search?: boolean | ContentSearchOptions
+  schema?: Schema
+}
+
+export interface DefinedCollection<
+  Schema extends StandardSchemaV1<any, any> | undefined = StandardSchemaV1<any, any> | undefined,
+> extends ContentCollectionDefinition<Schema> {
+  readonly [CONTENT_COLLECTION_MARKER]: true
+}
+
+export type AnyCollection = DefinedCollection<StandardSchemaV1<any, any> | undefined>
+
+export type InferCollectionData<Collection extends AnyCollection> =
+  Collection extends DefinedCollection<infer Schema>
+    ? Schema extends StandardSchemaV1<any, any>
+      ? InferStandardSchemaOutput<Schema>
+      : Record<string, unknown>
+    : Record<string, unknown>
+
+export interface BaseContentEntry<
+  Data = Record<string, unknown>,
+  Collection extends string = string,
+> {
+  body: string
+  collection: Collection
+  data: Data
+  filePath: string
+  id: string
+}
+
+export interface ContentHeading {
+  depth: number
+  slug: string
+  text: string
+}
+
+export interface ContentComponentProps extends Record<string, unknown> {
+  as?: string
+  html: string
+}
+
+export interface RenderedContent {
+  Content: (props?: Omit<ContentComponentProps, 'html'>) => any
+  headings: ContentHeading[]
+  html: string
+}
+
+export type CollectionEntry<Collection extends AnyCollection = AnyCollection> = BaseContentEntry<
+  InferCollectionData<Collection>
+>
+
+export type ContentFilter<Collection extends AnyCollection> = (
+  entry: CollectionEntry<Collection>,
+) => boolean | Promise<boolean>
+
+export interface ContentEntryReference<Collection extends AnyCollection = AnyCollection> {
+  collection: Collection
+  id: string
+}
+
+export type ResolvedContentEntries<Entries extends readonly ContentEntryReference<any>[]> = {
+  [Index in keyof Entries]: Entries[Index] extends ContentEntryReference<infer Collection>
+    ? CollectionEntry<Collection> | undefined
+    : never
+}

package/virtual-runtime.d.ts

@@ -0,0 +1,24 @@
+declare module 'virtual:eclipsa-content:runtime' {
+  export function getCollection<Collection extends import('./types.ts').AnyCollection>(
+    collection: Collection,
+    filter?: import('./mod.ts').ContentFilter<Collection>,
+  ): Promise<import('./mod.ts').CollectionEntry<Collection>[]>
+  export function getEntries<
+    Entries extends readonly import('./types.ts').ContentEntryReference<any>[],
+  >(entries: Entries): Promise<import('./types.ts').ResolvedContentEntries<Entries>>
+  export function getEntry<Collection extends import('./types.ts').AnyCollection>(
+    collection: Collection,
+    id: string,
+  ): Promise<import('./mod.ts').CollectionEntry<Collection> | undefined>
+  export function render<Collection extends import('./types.ts').AnyCollection>(
+    entry: import('./mod.ts').CollectionEntry<Collection>,
+  ): Promise<import('./types.ts').RenderedContent>
+}
+
+declare module 'virtual:eclipsa-content:search' {
+  export const searchOptions: import('./types.ts').ResolvedContentSearchOptions
+  export function search(
+    query: string,
+    options?: import('./types.ts').ContentSearchQueryOptions,
+  ): Promise<import('./types.ts').ContentSearchResult[]>
+}

package/vite-config.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest'
+import config from './vite.config.ts'
+
+describe('@eclipsa/content vite pack config', () => {
+  it('builds every published entrypoint with declarations', () => {
+    expect(config.pack).toMatchObject({
+      clean: true,
+      copy: ['virtual-runtime.d.ts'],
+      dts: true,
+      entry: ['mod.ts', 'vite.ts', 'internal.ts'],
+      format: ['esm'],
+      sourcemap: true,
+    })
+  })
+})

package/vite.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'vite-plus'
+
+export default defineConfig({
+  test: {
+    include: ['*.test.ts', '*.test.tsx'],
+    environment: 'node',
+  },
+  pack: {
+    copy: ['virtual-runtime.d.ts'],
+    entry: ['mod.ts', 'vite.ts', 'internal.ts'],
+    dts: true,
+    format: ['esm'],
+    clean: true,
+    sourcemap: true,
+  },
+})

package/vite.test.ts

@@ -0,0 +1,283 @@
+import * as fs from 'node:fs/promises'
+import * as os from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type { Plugin } from 'vite'
+import { eclipsaContent } from './vite.ts'
+
+const DEV_APP_INVALIDATORS_KEY = Symbol.for('eclipsa.dev-app-invalidators')
+const createdRoots: string[] = []
+const contentEntryImportPath = JSON.stringify(path.resolve(__dirname, 'mod.ts'))
+
+const createTempRoot = async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'eclipsa-content-vite-'))
+  createdRoots.push(root)
+  await fs.mkdir(path.join(root, 'app'), {
+    recursive: true,
+  })
+  return root
+}
+
+const getPlugin = (): Plugin => {
+  const plugin = eclipsaContent()
+  if (!Array.isArray(plugin)) {
+    throw new Error('Expected eclipsaContent() to return a plugin array')
+  }
+  return plugin[0] as Plugin
+}
+
+const getHotUpdate = (plugin: Plugin) => {
+  const hook = plugin.hotUpdate
+  if (typeof hook === 'function') {
+    return hook
+  }
+  return hook?.handler
+}
+
+afterEach(async () => {
+  await Promise.all(
+    createdRoots.splice(0).map((root) => fs.rm(root, { force: true, recursive: true })),
+  )
+})
+
+describe('@eclipsa/content vite plugin', () => {
+  it('returns a failing runtime module when content config is missing', async () => {
+    const root = await createTempRoot()
+    const plugin = getPlugin()
+    const configResolved =
+      typeof plugin.configResolved === 'function'
+        ? plugin.configResolved
+        : plugin.configResolved?.handler
+    await configResolved?.call(
+      {} as any,
+      {
+        root,
+      } as any,
+    )
+
+    const load = typeof plugin.load === 'function' ? plugin.load : plugin.load?.handler
+    const code = await load?.call({} as any, '\0eclipsa-content:runtime')
+
+    expect(code).toContain('Missing app/content.config.ts')
+  })
+
+  it('builds a runtime module that imports the app content config', async () => {
+    const root = await createTempRoot()
+    await fs.writeFile(path.join(root, 'app', 'content.config.ts'), 'export const docs = {}')
+    const plugin = getPlugin()
+    const configResolved =
+      typeof plugin.configResolved === 'function'
+        ? plugin.configResolved
+        : plugin.configResolved?.handler
+    await configResolved?.call(
+      {} as any,
+      {
+        root,
+      } as any,
+    )
+
+    const load = typeof plugin.load === 'function' ? plugin.load : plugin.load?.handler
+    const code = await load?.call({} as any, '\0eclipsa-content:runtime')
+
+    expect(code).toContain('@eclipsa/content/internal')
+    expect(code).toContain('app/content.config.ts')
+  })
+
+  it('builds a search runtime module when search is enabled', async () => {
+    const root = await createTempRoot()
+    await fs.mkdir(path.join(root, 'app', 'content', 'docs'), {
+      recursive: true,
+    })
+    await fs.writeFile(
+      path.join(root, 'app', 'content.config.ts'),
+      `
+import { defineCollection, glob } from ${contentEntryImportPath}
+
+export const docs = defineCollection({
+  loader: glob({
+    base: './content/docs',
+    pattern: '**/*.md',
+  }),
+  search: {
+    placeholder: 'Search docs',
+  },
+})
+`,
+    )
+    await fs.writeFile(
+      path.join(root, 'app', 'content', 'docs', 'page.md'),
+      `---
+title: Search Page
+---
+# Search Page
+
+Find the comet needle.
+`,
+    )
+
+    const plugin = getPlugin()
+    const configResolved =
+      typeof plugin.configResolved === 'function'
+        ? plugin.configResolved
+        : plugin.configResolved?.handler
+    await configResolved?.call(
+      {} as any,
+      {
+        base: '/',
+        root,
+      } as any,
+    )
+
+    const load = typeof plugin.load === 'function' ? plugin.load : plugin.load?.handler
+    const code = await load?.call(
+      { environment: { name: 'client' } } as any,
+      '\0eclipsa-content:search',
+    )
+
+    expect(code).toContain('__eclipsa_content_search__.json')
+    expect(code).toContain('searchOptions')
+    expect(code).not.toContain('import type')
+    expect(code).not.toContain(': Promise<')
+  })
+
+  it('stubs content config collections in the client environment', async () => {
+    const root = await createTempRoot()
+    const configPath = path.join(root, 'app', 'content.config.ts')
+    await fs.writeFile(
+      configPath,
+      `
+import { defineCollection } from '@eclipsa/content'
+import { z } from 'zod'
+
+export const docs = defineCollection({ loader: { load: () => [] }, schema: z.object({ title: z.string() }) })
+export const posts = defineCollection({ loader: { load: () => [] } })
+`,
+    )
+    const plugin = getPlugin()
+    const configResolved =
+      typeof plugin.configResolved === 'function'
+        ? plugin.configResolved
+        : plugin.configResolved?.handler
+    await configResolved?.call(
+      {} as any,
+      {
+        root,
+      } as any,
+    )
+
+    const load = typeof plugin.load === 'function' ? plugin.load : plugin.load?.handler
+    const code = await load?.call(
+      {
+        environment: {
+          name: 'client',
+        },
+      } as any,
+      configPath,
+    )
+
+    expect(code).toContain('export const docs = Object.freeze')
+    expect(code).toContain('export const posts = Object.freeze')
+    expect(code).not.toContain('zod')
+  })
+
+  it('invalidates registered dev apps and emits a content HMR event for markdown changes', async () => {
+    const root = await createTempRoot()
+    const plugin = getPlugin()
+    const configResolved =
+      typeof plugin.configResolved === 'function'
+        ? plugin.configResolved
+        : plugin.configResolved?.handler
+    await configResolved?.call(
+      {} as any,
+      {
+        root,
+      } as any,
+    )
+
+    const invalidate = vi.fn()
+    const send = vi.fn()
+    const hotUpdate = getHotUpdate(plugin)
+
+    const result = await hotUpdate?.call(
+      {} as any,
+      {
+        file: path.join(root, 'app', 'content', 'docs', 'guide', 'page.md'),
+        modules: [],
+        read: () => '',
+        server: {
+          [DEV_APP_INVALIDATORS_KEY]: new Set([invalidate]),
+          environments: {
+            ssr: {
+              moduleGraph: {
+                getModuleById: vi.fn(),
+                invalidateModule: vi.fn(),
+              },
+            },
+          },
+          ws: {
+            send,
+          },
+        },
+        timestamp: Date.now(),
+        type: 'update',
+      } as any,
+    )
+
+    expect(invalidate).toHaveBeenCalledTimes(1)
+    expect(send).toHaveBeenCalledWith('eclipsa:content-update')
+    expect(result).toEqual([])
+  })
+
+  it('emits a search index asset during bundle generation when search is enabled', async () => {
+    const root = await createTempRoot()
+    await fs.mkdir(path.join(root, 'app', 'content', 'docs'), {
+      recursive: true,
+    })
+    await fs.writeFile(
+      path.join(root, 'app', 'content.config.ts'),
+      `
+import { defineCollection, glob } from ${contentEntryImportPath}
+
+export const docs = defineCollection({
+  loader: glob({
+    base: './content/docs',
+    pattern: '**/*.md',
+  }),
+  search: true,
+})
+`,
+    )
+    await fs.writeFile(
+      path.join(root, 'app', 'content', 'docs', 'page.md'),
+      '# Search Asset\n\nMeteor shard token.',
+    )
+
+    const plugin = getPlugin()
+    const configResolved =
+      typeof plugin.configResolved === 'function'
+        ? plugin.configResolved
+        : plugin.configResolved?.handler
+    await configResolved?.call(
+      {} as any,
+      {
+        base: '/',
+        root,
+      } as any,
+    )
+
+    const emitFile = vi.fn()
+    const generateBundle =
+      typeof plugin.generateBundle === 'function'
+        ? plugin.generateBundle
+        : plugin.generateBundle?.handler
+
+    await generateBundle?.call({ emitFile } as any, {} as any, {} as any, false)
+
+    expect(emitFile).toHaveBeenCalledWith(
+      expect.objectContaining({
+        fileName: '__eclipsa_content_search__.json',
+        type: 'asset',
+      }),
+    )
+  })
+})