@wix/zero-config-implementation 1.6.0 → 1.7.0

package/dist/module-loader.d.ts

@@ -0,0 +1,20 @@
+import { ResultAsync } from 'neverthrow';
+import { ComponentType } from 'react';
+import { IoError } from './errors';
+type IoErrorInstance = InstanceType<typeof IoError>;
+/**
+ * Attempts to load a module, first via ESM `import()`, then via CJS `require`.
+ *
+ * ESM `import()` is preferred because it participates in the ESM loader hook
+ * pipeline (registered via `module.register()` in the CLI). This is required
+ * for JSX interception to work — the loader hook redirects `react/jsx-runtime`
+ * to the interceptable version. CJS `require()` bypasses ESM hooks even when
+ * loading ESM modules (Node 22+), so it's only used as a fallback.
+ *
+ * @param entryPath - Absolute path to the module entry point.
+ * @returns A `ResultAsync` containing the module exports on success.
+ * @errors {IoError} When both ESM import and CJS require fail.
+ */
+export declare function loadModule(entryPath: string): ResultAsync<Record<string, unknown>, IoErrorInstance>;
+export declare function findComponent(moduleExports: Record<string, unknown>, name: string): ComponentType<unknown> | null;
+export {};

package/dist/schema.d.ts

@@ -77,6 +77,7 @@ export declare const DATA: {
         readonly edgeAnchorLinks: "edgeAnchorLinks";
         readonly loginToWixLink: "loginToWixLink";
     };
+    WIX_TYPE_TO_DATA_TYPE: Record<string, "number" | "function" | "UNKNOWN_DataType" | "text" | "textEnum" | "booleanValue" | "a11y" | "link" | "image" | "video" | "vectorArt" | "audio" | "schema" | "localDate" | "localTime" | "localDateTime" | "webUrl" | "email" | "phone" | "hostname" | "regex" | "guid" | "richText" | "container" | "arrayItems" | "direction" | "menuItems" | "data" | "onClick" | "onChange" | "onKeyPress" | "onKeyUp" | "onSubmit">;
 };
 export declare const MEDIA: {
     VIDEO_CATEGORY: {

package/package.json

@@ -4,7 +4,7 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Core library for extracting component manifests from JS and CSS files",
   "type": "module",
   "main": "dist/index.js",
@@ -50,14 +50,11 @@
     "modern-errors-cli": "^6.0.0",
     "neverthrow": "^8.2.0",
     "parse5": "^7.1.2",
-    "pkg-entry-points": "^1.1.1",
     "react-docgen-typescript": "^2.4.0",
-    "read-package-up": "^11.0.0",
     "tsconfck": "^3.1.6",
     "typedoc": "^0.28.16",
     "typedoc-plugin-markdown": "^4.9.0",
     "vite": "^7.3.1",
-    "vite-node": "^5.3.0",
     "vite-plugin-dts": "^4.5.4",
     "vitest": "^4.0.17"
   },
@@ -77,5 +74,5 @@
       ]
     }
   },
-  "falconPackageHash": "bff28693b4f361afc6884e6bd88e888aaa2338365192170e935df129"
+  "falconPackageHash": "95c3bb44ab2a1406f75946ef5d30cec9f4ce31059113151e31289d75"
 }

package/src/converters/data-item-builder.ts

@@ -12,7 +12,6 @@
  * resolved type metadata is inconsistent (kind === 'array' but no elementType).
  */
 
-import { camelCase } from 'case-anything'
 import type { Result } from 'neverthrow'
 import { err, ok } from 'neverthrow'
 import { ParseError } from '../errors'
@@ -21,7 +20,7 @@ import type { DataItem } from '../schema'
 import { DATA, MEDIA } from '../schema'
 import { formatDisplayName } from './utils'
 
-const { DATA_TYPE } = DATA
+const { DATA_TYPE, WIX_TYPE_TO_DATA_TYPE } = DATA
 
 type ParseErrorInstance = InstanceType<typeof ParseError>
 
@@ -279,10 +278,10 @@ function handleSemanticType(dataItem: DataItem, resolvedType: ResolvedType): voi
     return
   }
 
-  // Wix public-schemas (Builder) types - map directly to DATA_TYPE via camelCase conversion
+  // Wix public-schemas (Builder) types - map directly to DATA_TYPE via explicit lookup
   if (source === '@wix/public-schemas') {
-    const dataTypeKey = camelCase(semanticValue) as keyof typeof DATA_TYPE
-    if (dataTypeKey in DATA_TYPE) {
+    const dataTypeKey = WIX_TYPE_TO_DATA_TYPE[semanticValue]
+    if (dataTypeKey) {
       dataItem.dataType = DATA_TYPE[dataTypeKey]
       applyDataToBuilderType(dataItem, dataTypeKey)
     } else {

package/src/converters/utils.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest'
+import { formatDisplayName } from './utils'
+
+describe('formatDisplayName', () => {
+  it('maps a11y to Accessibility', () => {
+    expect(formatDisplayName('a11y')).toBe('Accessibility')
+  })
+
+  it('formats kebab-case', () => {
+    expect(formatDisplayName('input-field-weight')).toBe('Input Field Weight')
+  })
+
+  it('formats camelCase', () => {
+    expect(formatDisplayName('camelCaseExample')).toBe('Camel Case Example')
+  })
+})

package/src/converters/utils.ts

@@ -4,6 +4,10 @@
 
 import { capitalCase } from 'case-anything'
 
+const DISPLAY_NAME_OVERRIDES = {
+  a11y: 'Accessibility',
+} as const
+
 /**
  * Formats any string format to Title Case display name
  * Handles: kebab-case, camelCase, PascalCase, snake_case, SCREAMING_SNAKE_CASE, and mixed formats
@@ -15,7 +19,11 @@ import { capitalCase } from 'case-anything'
  *   "snake_case_example" -> "Snake Case Example"
  *   "SCREAMING_SNAKE_CASE" -> "Screaming Snake Case"
  *   "mixed-format_example" -> "Mixed Format Example"
+ *   "a11y" -> "Accessibility"
  */
 export function formatDisplayName(input: string): string {
+  if (input in DISPLAY_NAME_OVERRIDES) {
+    return DISPLAY_NAME_OVERRIDES[input as keyof typeof DISPLAY_NAME_OVERRIDES]
+  }
   return capitalCase(input, { keepSpecialCharacters: false })
 }

package/src/index.ts

@@ -11,7 +11,7 @@ import { compileTsFile } from './ts-compiler'
 import { type NotFoundError, ParseError } from './errors'
 
 // Component loader helpers
-import { findComponent, loadModule } from './component-loader'
+import { findComponent, loadModule } from './module-loader'
 
 // Pipeline orchestration
 import { processComponent } from './manifest-pipeline'
@@ -104,7 +104,7 @@ export function extractComponentManifest(
           // Surface loader error as a non-fatal error
           if (loaderError) {
             errors.push({
-              componentName: compiledEntryPath,
+              componentName: componentInfo.componentName,
               phase: 'loader',
               error: loaderError,
             })
@@ -216,8 +216,8 @@ export {
   withDefectBoundary,
 } from './errors'
 
-/** Component loader */
-export { createComponentLoader } from './component-loader'
+/** Module loader primitives */
+export { loadModule, findComponent } from './module-loader'
 
 // ── Tier 3: Low-Level Renderer ──────────────────────────────────────────────
 

package/src/information-extractors/ts/components.ts

@@ -158,7 +158,19 @@ function findPropsType(
   if (!moduleSymbol) return undefined
 
   const exports = checker.getExportsOfModule(moduleSymbol)
-  const componentSymbol = exports.find((s) => s.getName() === componentName)
+  let componentSymbol = exports.find((s) => s.getName() === componentName)
+
+  // If not found by name, check whether the default export resolves to the component
+  if (!componentSymbol) {
+    const defaultSymbol = exports.find((s) => s.getName() === 'default')
+    if (defaultSymbol && (defaultSymbol.getFlags() & ts.SymbolFlags.Alias) !== 0) {
+      const resolved = checker.getAliasedSymbol(defaultSymbol)
+      if (resolved.getName() === componentName) {
+        componentSymbol = resolved
+      }
+    }
+  }
+
   if (!componentSymbol) return undefined
 
   const componentType = checker.getTypeOfSymbol(componentSymbol)

package/src/information-extractors/ts/utils/semantic-type-resolver.ts

@@ -1,13 +1,12 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
-import { camelCase } from 'case-anything'
 import ts from 'typescript'
 import { DATA } from '../../../schema'
 import type { PropInfo, ResolvedType } from '../types'
 
 const MAX_RESOLVE_DEPTH = 30
 
-const { DATA_TYPE } = DATA
+const { WIX_TYPE_TO_DATA_TYPE } = DATA
 
 /**
  * Cache for package name lookups
@@ -50,8 +49,7 @@ const VALID_REACT_SEMANTIC_TYPES = new Set(['ReactNode', 'ReactElement'])
  * Checks if a Wix type name maps to a valid DATA_TYPE key
  */
 function isValidWixSemanticType(symbolName: string): boolean {
-  const camelCaseKey = camelCase(symbolName)
-  return camelCaseKey in DATA_TYPE
+  return symbolName in WIX_TYPE_TO_DATA_TYPE
 }
 
 /**

package/src/module-loader.ts

@@ -0,0 +1,76 @@
+import { createRequire } from 'node:module'
+import { pascalCase } from 'case-anything'
+import { ResultAsync, errAsync, okAsync } from 'neverthrow'
+import type { ComponentType } from 'react'
+import { IoError } from './errors'
+
+type IoErrorInstance = InstanceType<typeof IoError>
+
+/**
+ * Attempts to load a module, first via ESM `import()`, then via CJS `require`.
+ *
+ * ESM `import()` is preferred because it participates in the ESM loader hook
+ * pipeline (registered via `module.register()` in the CLI). This is required
+ * for JSX interception to work — the loader hook redirects `react/jsx-runtime`
+ * to the interceptable version. CJS `require()` bypasses ESM hooks even when
+ * loading ESM modules (Node 22+), so it's only used as a fallback.
+ *
+ * @param entryPath - Absolute path to the module entry point.
+ * @returns A `ResultAsync` containing the module exports on success.
+ * @errors {IoError} When both ESM import and CJS require fail.
+ */
+export function loadModule(entryPath: string): ResultAsync<Record<string, unknown>, IoErrorInstance> {
+  return ResultAsync.fromPromise(import(entryPath) as Promise<Record<string, unknown>>, () => null).orElse(() => {
+    try {
+      const require = createRequire(import.meta.url)
+      const exports = require(entryPath)
+      return okAsync(exports as Record<string, unknown>)
+    } catch (requireErr) {
+      const cause = requireErr instanceof Error ? requireErr : new Error(String(requireErr))
+      return errAsync(
+        new IoError(`Failed to load ${entryPath}: ${cause.message}`, {
+          cause,
+          props: { phase: 'load' },
+        }),
+      )
+    }
+  })
+}
+
+function isPascalCase(name: string): boolean {
+  return name.length > 0 && pascalCase(name) === name
+}
+
+function isComponent(value: unknown): value is ComponentType<unknown> {
+  if (typeof value === 'function') return isPascalCase(value.name)
+  // React.memo() and React.forwardRef() return objects, not functions
+  if (typeof value === 'object' && value !== null && '$$typeof' in value) return true
+  return false
+}
+
+export function findComponent(moduleExports: Record<string, unknown>, name: string): ComponentType<unknown> | null {
+  // Direct named export
+  const direct = moduleExports[name]
+  if ((typeof direct === 'function' && isPascalCase(name)) || isComponent(direct)) {
+    return direct as ComponentType<unknown>
+  }
+
+  // Check default export
+  const defaultExport = moduleExports.default
+  if (defaultExport) {
+    // default is the component itself (matches by function name)
+    if (typeof defaultExport === 'function' && defaultExport.name === name) {
+      return defaultExport as ComponentType<unknown>
+    }
+
+    // CJS interop: default is an object with named exports
+    if (typeof defaultExport === 'object' && defaultExport !== null) {
+      const nested = (defaultExport as Record<string, unknown>)[name]
+      if (isComponent(nested)) {
+        return nested as ComponentType<unknown>
+      }
+    }
+  }
+
+  return null
+}

package/src/schema.ts

@@ -116,7 +116,39 @@ const ELEMENT_TYPE = {
   refElement: 'refElement',
 } as const
 
-export const DATA = { DATA_TYPE, A11Y_ATTRIBUTES, LINK_TYPE }
+/**
+ * Maps @wix/public-schemas type names (PascalCase) to their DATA_TYPE keys.
+ * Derived from the exports of @wix/public-schemas.
+ */
+const WIX_TYPE_TO_DATA_TYPE: Record<string, keyof typeof DATA_TYPE> = {
+  Link: 'link',
+  Image: 'image',
+  Video: 'video',
+  VectorArt: 'vectorArt',
+  A11y: 'a11y',
+  Audio: 'audio',
+  MenuItems: 'menuItems',
+  Schema: 'schema',
+  Text: 'text',
+  TextEnum: 'textEnum',
+  NumberType: 'number',
+  BooleanValue: 'booleanValue',
+  LocalDate: 'localDate',
+  LocalTime: 'localTime',
+  LocalDateTime: 'localDateTime',
+  WebUrl: 'webUrl',
+  Email: 'email',
+  Phone: 'phone',
+  Hostname: 'hostname',
+  Regex: 'regex',
+  Guid: 'guid',
+  RichText: 'richText',
+  Container: 'container',
+  ArrayItems: 'arrayItems',
+  Direction: 'direction',
+}
+
+export const DATA = { DATA_TYPE, A11Y_ATTRIBUTES, LINK_TYPE, WIX_TYPE_TO_DATA_TYPE }
 export const MEDIA = { VIDEO_CATEGORY, VECTOR_ART_CATEGORY, IMAGE_CATEGORY }
 export const ELEMENTS = { ELEMENT_TYPE }
 

package/vite.config.ts

@@ -25,6 +25,12 @@ export default defineConfig({
         if (id.startsWith('node:') || builtinModules.includes(id) || ['typescript', 'lightningcss'].includes(id)) {
           return true
         }
+        // Externalize React so the host project's React instance is used at runtime.
+        // Bundling React creates a second instance that causes hook failures when
+        // user components resolve a different React from their own node_modules.
+        if (id === 'react' || id === 'react-dom' || id.startsWith('react/') || id.startsWith('react-dom/')) {
+          return true
+        }
         return false
       },
     },

package/dist/component-loader.d.ts

@@ -1,42 +0,0 @@
-import { ResultAsync } from 'neverthrow';
-import { ComponentType } from 'react';
-import { IoError, NotFoundError } from './errors';
-type NotFoundErrorInstance = InstanceType<typeof NotFoundError>;
-type IoErrorInstance = InstanceType<typeof IoError>;
-export type LoaderError = NotFoundErrorInstance | IoErrorInstance;
-export interface ComponentLoaderResult {
-    loadComponent: (name: string) => ComponentType<unknown> | null;
-    packageName: string;
-    entryPath: string | undefined;
-    exportNames: string[];
-}
-/**
- * Creates a component loader that dynamically loads components from the
- * user's package. Finds the nearest package.json, resolves its entry point,
- * and loads the module.
- *
- * The returned `loadComponent` is synchronous (required by processComponent).
- * ESM modules are loaded via async `import()` during creation, so this
- * function itself is async.
- *
- * @returns A `ResultAsync` containing a `ComponentLoaderResult` on success.
- * @errors {NotFoundError} When no package.json is found or the package has no resolvable entry points.
- * @errors {IoError} When module loading fails (CJS require or ESM import).
- */
-export declare function createComponentLoader(componentPath: string): ResultAsync<ComponentLoaderResult, LoaderError>;
-/**
- * Attempts to load a module, first via ESM `import()`, then via CJS `require`.
- *
- * ESM `import()` is preferred because it participates in the ESM loader hook
- * pipeline (registered via `module.register()` in the CLI). This is required
- * for JSX interception to work — the loader hook redirects `react/jsx-runtime`
- * to the interceptable version. CJS `require()` bypasses ESM hooks even when
- * loading ESM modules (Node 22+), so it's only used as a fallback.
- *
- * @param entryPath - Absolute path to the module entry point.
- * @returns A `ResultAsync` containing the module exports on success.
- * @errors {IoError} When both ESM import and CJS require fail.
- */
-export declare function loadModule(entryPath: string): ResultAsync<Record<string, unknown>, IoErrorInstance>;
-export declare function findComponent(moduleExports: Record<string, unknown>, name: string): ComponentType<unknown> | null;
-export {};

package/src/component-loader.test.ts

@@ -1,277 +0,0 @@
-import { join } from 'node:path'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const mockModuleRequire = vi.fn()
-
-vi.mock('node:module', () => ({
-  createRequire: () => mockModuleRequire,
-}))
-
-vi.mock('read-package-up', () => ({
-  readPackageUpSync: vi.fn(),
-}))
-
-vi.mock('pkg-entry-points', () => ({
-  getPackageEntryPoints: vi.fn(),
-}))
-
-import { getPackageEntryPoints } from 'pkg-entry-points'
-import type { NormalizedPackageJson } from 'read-package-up'
-import { readPackageUpSync } from 'read-package-up'
-import { createComponentLoader } from './component-loader'
-
-const mockReadPackageUp = vi.mocked(readPackageUpSync)
-const mockGetEntryPoints = vi.mocked(getPackageEntryPoints)
-
-const fakePkgDir = '/fake/project'
-const fakePkgJsonPath = join(fakePkgDir, 'package.json')
-
-function mockPackage(name: string) {
-  mockReadPackageUp.mockReturnValue({
-    packageJson: { name } as NormalizedPackageJson,
-    path: fakePkgJsonPath,
-  })
-}
-
-beforeEach(() => {
-  vi.resetAllMocks()
-  mockModuleRequire.mockImplementation(() => {
-    throw new Error('Cannot find module')
-  })
-})
-
-describe('createComponentLoader', () => {
-  it('returns error when no package.json is found', async () => {
-    mockReadPackageUp.mockReturnValue(undefined)
-
-    const result = await createComponentLoader('/some/Component.tsx')
-
-    expect(result.isErr()).toBe(true)
-    if (result.isErr()) {
-      expect(result.error.message).toBe('No package.json found')
-    }
-  })
-
-  it('returns error when package has no resolvable entry points', async () => {
-    mockPackage('my-pkg')
-    mockGetEntryPoints.mockResolvedValue({})
-
-    const result = await createComponentLoader(join(fakePkgDir, 'src/Component.tsx'))
-
-    expect(result.isErr()).toBe(true)
-    if (result.isErr()) {
-      expect(result.error.message).toContain('no resolvable entry point')
-      expect(result.error.message).toContain('my-pkg')
-    }
-  })
-
-  it('returns error when only types exports exist', async () => {
-    mockPackage('types-only')
-    mockGetEntryPoints.mockResolvedValue({
-      '.': [[['types'], './dist/index.d.ts']],
-    })
-
-    const result = await createComponentLoader(join(fakePkgDir, 'src/Component.tsx'))
-
-    expect(result.isErr()).toBe(true)
-    if (result.isErr()) {
-      expect(result.error.message).toContain('no loadable exports')
-    }
-  })
-
-  it('returns error with path when single entry point fails to load', async () => {
-    mockPackage('bad-entry')
-    mockGetEntryPoints.mockResolvedValue({
-      '.': [[['import'], './dist/index.js']],
-    })
-
-    const result = await createComponentLoader(join(fakePkgDir, 'src/Component.tsx'))
-
-    expect(result.isErr()).toBe(true)
-    if (result.isErr()) {
-      expect(result.error.message).toContain('Failed to load')
-      expect(result.error.message).toContain(join(fakePkgDir, 'dist/index.js'))
-    }
-  })
-
-  it('returns error when multiple subpath exports all fail to load', async () => {
-    mockPackage('multi-fail')
-    mockGetEntryPoints.mockResolvedValue({
-      './foo': [[['import'], './dist/foo.js']],
-      './bar': [[['import'], './dist/bar.js']],
-    })
-
-    const result = await createComponentLoader(join(fakePkgDir, 'src/Component.tsx'))
-
-    expect(result.isErr()).toBe(true)
-    if (result.isErr()) {
-      expect(result.error.message).toContain('Failed to load')
-    }
-  })
-
-  it('skips types-only entries in multi-subpath exports', async () => {
-    mockPackage('mixed-types')
-    mockGetEntryPoints.mockResolvedValue({
-      './types': [[['types'], './dist/types.d.ts']],
-      './runtime': [[['import'], './dist/does-not-exist.js']],
-    })
-
-    const result = await createComponentLoader(join(fakePkgDir, 'src/Component.tsx'))
-
-    // ./types should be skipped (selectBestPath returns undefined), ./runtime fails to load
-    expect(result.isErr()).toBe(true)
-    if (result.isErr()) {
-      expect(result.error.message).toContain('Failed to load')
-    }
-  })
-})
-
-describe('selectBestPath (via createComponentLoader)', () => {
-  it('prefers import condition over node and default', async () => {
-    mockPackage('prio-test')
-    mockGetEntryPoints.mockResolvedValue({
-      '.': [
-        [['default'], './dist/default.js'],
-        [['node'], './dist/node.js'],
-        [['import'], './dist/import.js'],
-      ],
-    })
-
-    const result = await createComponentLoader(join(fakePkgDir, 'src/Component.tsx'))
-
-    // Module load will fail since these are fake paths, but entryPath is in the error
-    expect(result.isErr()).toBe(true)
-    if (result.isErr()) {
-      expect(result.error.message).toContain(join(fakePkgDir, 'dist/import.js'))
-    }
-  })
-
-  it('falls back to node condition when import is not available', async () => {
-    mockPackage('node-fallback')
-    mockGetEntryPoints.mockResolvedValue({
-      '.': [
-        [['default'], './dist/default.js'],
-        [['node'], './dist/node.js'],
-      ],
-    })
-
-    const result = await createComponentLoader(join(fakePkgDir, 'src/Component.tsx'))
-
-    expect(result.isErr()).toBe(true)
-    if (result.isErr()) {
-      expect(result.error.message).toContain(join(fakePkgDir, 'dist/node.js'))
-    }
-  })
-
-  it('falls back to default condition when import and node are not available', async () => {
-    mockPackage('default-fallback')
-    mockGetEntryPoints.mockResolvedValue({
-      '.': [[['default'], './dist/default.js']],
-    })
-
-    const result = await createComponentLoader(join(fakePkgDir, 'src/Component.tsx'))
-
-    expect(result.isErr()).toBe(true)
-    if (result.isErr()) {
-      expect(result.error.message).toContain(join(fakePkgDir, 'dist/default.js'))
-    }
-  })
-
-  it('skips entries that include types condition', async () => {
-    mockPackage('skip-types')
-    mockGetEntryPoints.mockResolvedValue({
-      '.': [
-        [['import', 'types'], './dist/index.d.ts'],
-        [['import'], './dist/index.js'],
-      ],
-    })
-
-    const result = await createComponentLoader(join(fakePkgDir, 'src/Component.tsx'))
-
-    expect(result.isErr()).toBe(true)
-    if (result.isErr()) {
-      expect(result.error.message).toContain(join(fakePkgDir, 'dist/index.js'))
-    }
-  })
-})
-
-describe('error message quality', () => {
-  it('includes package name in error messages', async () => {
-    mockPackage('@scope/my-components')
-    mockGetEntryPoints.mockResolvedValue({})
-
-    const result = await createComponentLoader(join(fakePkgDir, 'src/Component.tsx'))
-
-    expect(result.isErr()).toBe(true)
-    if (result.isErr()) {
-      expect(result.error.message).toContain('@scope/my-components')
-    }
-  })
-
-  it('includes package.json path in no-entry-point error', async () => {
-    mockPackage('no-entry')
-    mockGetEntryPoints.mockResolvedValue({})
-
-    const result = await createComponentLoader(join(fakePkgDir, 'src/Component.tsx'))
-
-    expect(result.isErr()).toBe(true)
-    if (result.isErr()) {
-      expect(result.error.message).toContain(fakePkgJsonPath)
-    }
-  })
-})
-
-describe('component resolution behavior', () => {
-  it('fails today for direct named export when function name is minified', async () => {
-    const packageDir = '/fake/minified-export-test'
-    const packageJsonPath = join(packageDir, 'package.json')
-
-    mockReadPackageUp.mockReturnValue({
-      packageJson: { name: 'minified-export-test' } as NormalizedPackageJson,
-      path: packageJsonPath,
-    })
-    mockGetEntryPoints.mockResolvedValue({
-      '.': [[['import'], './dist/index.js']],
-    })
-    mockModuleRequire.mockImplementation(() => ({
-      CardX: function j() {
-        return null
-      },
-    }))
-
-    const result = await createComponentLoader(join(packageDir, 'src/CardX.tsx'))
-
-    expect(result.isOk()).toBe(true)
-    if (result.isOk()) {
-      const component = result.value.loadComponent('CardX')
-      // TDD red phase: this currently returns null because function.name === "j".
-      expect(component).not.toBeNull()
-    }
-  })
-
-  it('rejects direct function exports with non-PascalCase export keys', async () => {
-    const packageDir = '/fake/lowercase-export-test'
-    const packageJsonPath = join(packageDir, 'package.json')
-
-    mockReadPackageUp.mockReturnValue({
-      packageJson: { name: 'lowercase-export-test' } as NormalizedPackageJson,
-      path: packageJsonPath,
-    })
-    mockGetEntryPoints.mockResolvedValue({
-      '.': [[['import'], './dist/index.js']],
-    })
-    mockModuleRequire.mockImplementation(() => ({
-      helper: function j() {
-        return null
-      },
-    }))
-
-    const result = await createComponentLoader(join(packageDir, 'src/helper.ts'))
-
-    expect(result.isOk()).toBe(true)
-    if (result.isOk()) {
-      const component = result.value.loadComponent('helper')
-      expect(component).toBeNull()
-    }
-  })
-})