@open-mercato/ui 0.6.7-develop.6784.1.f80b9afce5 → 0.6.7-develop.6788.1.c2a1520a30

package/src/backend/icons/__tests__/lucideRegistryGenerator.test.ts

@@ -0,0 +1,177 @@
+import { execFileSync } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { Project, ScriptKind, SyntaxKind, type ObjectLiteralExpression, type SourceFile } from 'ts-morph'
+import { buildLucideRegistrySource } from '../../../../scripts/lucideRegistrySource.cjs'
+
+const packageDir = join(__dirname, '..', '..', '..', '..')
+const iconsDir = join(packageDir, 'src', 'backend', 'icons')
+
+type ResolvedIcon = { kebab: string; exportName: string }
+
+const populatedFixture: ResolvedIcon[] = [
+  { kebab: 'bell', exportName: 'Bell' },
+  { kebab: 'alert-circle', exportName: 'AlertCircle' },
+  { kebab: 'bar-chart-2', exportName: 'BarChart2' },
+]
+
+const duplicateExportFixture: ResolvedIcon[] = [
+  { kebab: 'trash', exportName: 'Trash' },
+  { kebab: 'trash-can', exportName: 'Trash' },
+]
+
+function parse(source: string): SourceFile {
+  const project = new Project({ useInMemoryFileSystem: true })
+  return project.createSourceFile('lucideRegistry.generated.tsx', source, {
+    overwrite: true,
+    scriptKind: ScriptKind.TSX,
+  })
+}
+
+function syntacticDiagnostics(source: string): string[] {
+  const sourceFile = parse(source)
+  return sourceFile
+    .getProject()
+    .getProgram()
+    .getSyntacticDiagnostics(sourceFile)
+    .map((diagnostic) => `${diagnostic.getLineNumber() ?? 0}: ${diagnostic.getMessageText()}`)
+}
+
+function registryObject(source: string): ObjectLiteralExpression {
+  const declaration = parse(source).getVariableDeclarationOrThrow('LUCIDE_ICON_REGISTRY')
+  return declaration.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression)
+}
+
+function registryEntries(source: string): Record<string, string> {
+  const entries: Record<string, string> = {}
+  for (const property of registryObject(source).getProperties()) {
+    const assignment = property.asKindOrThrow(SyntaxKind.PropertyAssignment)
+    entries[assignment.getSymbolOrThrow().getName()] = assignment.getInitializerOrThrow().getText()
+  }
+  return entries
+}
+
+function valueImportNames(source: string, moduleSpecifier: string): string[] {
+  return parse(source)
+    .getImportDeclarations()
+    .filter((declaration) => declaration.getModuleSpecifierValue() === moduleSpecifier)
+    .filter((declaration) => !declaration.isTypeOnly())
+    .flatMap((declaration) => declaration.getNamedImports().map((named) => named.getName()))
+}
+
+describe('buildLucideRegistrySource', () => {
+  it('maps every discovered kebab name to its lucide export', () => {
+    expect(registryEntries(buildLucideRegistrySource(populatedFixture))).toEqual({
+      'alert-circle': 'AlertCircle',
+      'bar-chart-2': 'BarChart2',
+      bell: 'Bell',
+    })
+  })
+
+  it('emits the registry keys sorted by kebab name', () => {
+    const keys = registryObject(buildLucideRegistrySource(populatedFixture))
+      .getProperties()
+      .map((property) => property.asKindOrThrow(SyntaxKind.PropertyAssignment).getSymbolOrThrow().getName())
+    expect(keys).toEqual(['alert-circle', 'bar-chart-2', 'bell'])
+  })
+
+  it('imports each lucide export exactly once', () => {
+    expect(valueImportNames(buildLucideRegistrySource(populatedFixture), 'lucide-react')).toEqual([
+      'AlertCircle',
+      'BarChart2',
+      'Bell',
+    ])
+  })
+
+  it('quotes keys that are not valid identifiers', () => {
+    const property = registryObject(buildLucideRegistrySource(populatedFixture))
+      .getPropertyOrThrow("'bar-chart-2'")
+      .asKindOrThrow(SyntaxKind.PropertyAssignment)
+    expect(property.getNameNode().getKind()).toBe(SyntaxKind.StringLiteral)
+  })
+
+  it('de-duplicates the value import when two names share one export', () => {
+    const source = buildLucideRegistrySource(duplicateExportFixture)
+    expect(valueImportNames(source, 'lucide-react')).toEqual(['Trash'])
+    expect(registryEntries(source)).toEqual({ trash: 'Trash', 'trash-can': 'Trash' })
+  })
+
+  it('emits a valid module with an empty registry when no icons are discovered', () => {
+    const source = buildLucideRegistrySource([])
+    expect(registryObject(source).getProperties()).toHaveLength(0)
+    expect(valueImportNames(source, 'lucide-react')).toEqual([])
+    expect(source).not.toContain("import {} from 'lucide-react'")
+  })
+
+  it('keeps the registry a plain mutable object literal', () => {
+    const source = buildLucideRegistrySource(populatedFixture)
+    const declaration = parse(source).getVariableDeclarationOrThrow('LUCIDE_ICON_REGISTRY')
+    expect(declaration.getTypeNodeOrThrow().getText()).toBe('Record<string, LucideIcon>')
+    expect(declaration.getVariableStatementOrThrow().isExported()).toBe(true)
+    expect(source).not.toContain('as const')
+    expect(source).not.toContain('Object.freeze')
+  })
+
+  it('keeps the LucideIcon import type-only', () => {
+    const typeOnly = parse(buildLucideRegistrySource(populatedFixture))
+      .getImportDeclarations()
+      .filter((declaration) => declaration.isTypeOnly())
+      .flatMap((declaration) => declaration.getNamedImports().map((named) => named.getName()))
+    expect(typeOnly).toEqual(['LucideIcon'])
+  })
+
+  it.each([
+    ['populated', populatedFixture],
+    ['empty', [] as ResolvedIcon[]],
+    ['duplicate exports', duplicateExportFixture],
+  ])('emits %s output with zero syntactic diagnostics', (_label, fixture) => {
+    expect(syntacticDiagnostics(buildLucideRegistrySource(fixture))).toEqual([])
+  })
+
+  it('fails loudly when an export name would produce an unparseable module', () => {
+    expect(() => buildLucideRegistrySource([{ kebab: 'broken', exportName: 'not a valid export' }])).toThrow(
+      /not syntactically valid/
+    )
+  })
+})
+
+describe('lucideRegistry barrel', () => {
+  it('keeps its public export list unchanged', () => {
+    const project = new Project({ useInMemoryFileSystem: true })
+    const barrel = project.createSourceFile(
+      'lucideRegistry.ts',
+      readFileSync(join(iconsDir, 'lucideRegistry.ts'), 'utf-8'),
+      { overwrite: true }
+    )
+    expect([...barrel.getExportedDeclarations().keys()].sort()).toEqual([
+      'LUCIDE_ICON_REGISTRY',
+      'registerAdditionalIcons',
+      'resolveRegisteredLucideIcon',
+      'resolveRegisteredLucideIconNode',
+    ])
+  })
+})
+
+describe('lucideRegistry.generated importers', () => {
+  it('is imported only from within src/backend/icons', () => {
+    const repoRoot = join(packageDir, '..', '..')
+    let matches: string[] = []
+    try {
+      matches = execFileSync(
+        'git',
+        ['grep', '-l', 'lucideRegistry.generated', '--', '*.ts', '*.tsx'],
+        { cwd: repoRoot, encoding: 'utf-8' }
+      )
+        .split('\n')
+        .filter(Boolean)
+    } catch (error) {
+      const status = (error as { status?: number }).status
+      if (status !== 1) throw error
+    }
+
+    const outsideIconsFolder = matches.filter(
+      (path) => !path.startsWith('packages/ui/src/backend/icons/')
+    )
+    expect(outsideIconsFolder).toEqual([])
+  })
+})

package/src/backend/icons/lucideRegistry.generated.tsx

@@ -2,8 +2,7 @@
 // AUTO-GENERATED by @open-mercato/ui build. Do not edit by hand.
 // Generated from discovered icon string usages across the repo.
 
-import type * as React from 'react'
-import type { LucideIcon } from 'lucide-react'
+import type { LucideIcon } from 'lucide-react';
 import {
   Activity,
   AlertCircle,
@@ -150,7 +149,7 @@ import {
   Wrench,
   X,
   XCircle,
-} from 'lucide-react'
+} from 'lucide-react';
 
 export const LUCIDE_ICON_REGISTRY: Record<string, LucideIcon> = {
   'activity': Activity,
@@ -298,37 +297,4 @@ export const LUCIDE_ICON_REGISTRY: Record<string, LucideIcon> = {
   'wrench': Wrench,
   'x': X,
   'x-circle': XCircle,
-}
-
-function normalizeKebabIconName(input: string): string {
-  const trimmed = input.trim()
-  if (!trimmed) return ''
-  const withoutPrefix = trimmed.startsWith('lucide:') ? trimmed.slice('lucide:'.length) : trimmed
-  if (!withoutPrefix) return ''
-  if (!withoutPrefix.includes('-') && !withoutPrefix.includes('_') && !withoutPrefix.includes(' ') && /[A-Z]/.test(withoutPrefix)) {
-    return withoutPrefix
-      .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-      .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
-      .toLowerCase()
-  }
-  return withoutPrefix
-    .replace(/[_\s]+/g, '-')
-    .replace(/-+/g, '-')
-    .toLowerCase()
-}
-
-export function resolveRegisteredLucideIcon(name: string | undefined): LucideIcon | null {
-  if (!name) return null
-  const normalized = normalizeKebabIconName(name)
-  if (!normalized) return null
-  return (LUCIDE_ICON_REGISTRY as Record<string, LucideIcon | undefined>)[normalized] ?? null
-}
-
-export function resolveRegisteredLucideIconNode(
-  name: string | undefined,
-  className: string
-): React.ReactNode | null {
-  const Icon = resolveRegisteredLucideIcon(name)
-  if (!Icon) return null
-  return <Icon className={className} />
-}
+};

package/src/backend/icons/lucideRegistry.ts

@@ -1,8 +1,8 @@
 export {
   resolveRegisteredLucideIcon,
   resolveRegisteredLucideIconNode,
-  LUCIDE_ICON_REGISTRY,
-} from './lucideRegistry.generated'
+} from './lucideRegistryRuntime'
+export { LUCIDE_ICON_REGISTRY } from './lucideRegistry.generated'
 
 import type { LucideIcon } from 'lucide-react'
 import { LUCIDE_ICON_REGISTRY } from './lucideRegistry.generated'

package/src/backend/icons/lucideRegistryRuntime.tsx

@@ -0,0 +1,36 @@
+import type * as React from 'react'
+import type { LucideIcon } from 'lucide-react'
+import { LUCIDE_ICON_REGISTRY } from './lucideRegistry.generated'
+
+function normalizeKebabIconName(input: string): string {
+  const trimmed = input.trim()
+  if (!trimmed) return ''
+  const withoutPrefix = trimmed.startsWith('lucide:') ? trimmed.slice('lucide:'.length) : trimmed
+  if (!withoutPrefix) return ''
+  if (!withoutPrefix.includes('-') && !withoutPrefix.includes('_') && !withoutPrefix.includes(' ') && /[A-Z]/.test(withoutPrefix)) {
+    return withoutPrefix
+      .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+      .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+      .toLowerCase()
+  }
+  return withoutPrefix
+    .replace(/[_\s]+/g, '-')
+    .replace(/-+/g, '-')
+    .toLowerCase()
+}
+
+export function resolveRegisteredLucideIcon(name: string | undefined): LucideIcon | null {
+  if (!name) return null
+  const normalized = normalizeKebabIconName(name)
+  if (!normalized) return null
+  return (LUCIDE_ICON_REGISTRY as Record<string, LucideIcon | undefined>)[normalized] ?? null
+}
+
+export function resolveRegisteredLucideIconNode(
+  name: string | undefined,
+  className: string
+): React.ReactNode | null {
+  const Icon = resolveRegisteredLucideIcon(name)
+  if (!Icon) return null
+  return <Icon className={className} />
+}