@wix/zero-config-implementation 1.78.0 → 1.79.0

package/dist/{index-DAAmOM1c.js → index-DCJue8M7.js}

@@ -1,4 +1,4 @@
-import { g as x } from "./index--6I20lGB.js";
+import { g as x } from "./index-CoU1WRYf.js";
 function h(r, a) {
   for (var i = 0; i < a.length; i++) {
     const o = a[i];

package/dist/index.js

@@ -1,4 +1,4 @@
-import { B as t, D as e, E as o, I as n, N as c, P as l, R as i, a as p, V as E, b as m, c as x, d as f, e as d, f as u, h as C, i as I, j as k, k as y, l as A, m as D, n as P, o as R, p as h, q as B, r as M, s as T, t as b, w } from "./index--6I20lGB.js";
+import { B as t, D as e, E as o, I as n, N as c, P as l, R as i, a as p, V as E, b as m, c as x, d as f, e as d, f as u, h as C, i as I, j as k, k as y, l as A, m as D, n as P, o as R, p as h, q as B, r as M, s as T, t as b, w } from "./index-CoU1WRYf.js";
 import "react";
 export {
   t as BaseError,

package/package.json

@@ -4,7 +4,7 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "version": "1.78.0",
+  "version": "1.79.0",
   "description": "Core library for extracting component manifests from JS and CSS files",
   "type": "module",
   "main": "dist/index.js",
@@ -82,5 +82,5 @@
       ]
     }
   },
-  "falconPackageHash": "7ea33e17604c8d13038271d43e3350d8bb9d9531ec0110efca2a7144"
+  "falconPackageHash": "95a755e580164c3acabbf27f3813514e4fcdb56b90214e7b830134af"
 }

package/src/converters/to-editor-component.ts

@@ -11,6 +11,8 @@ import type {
 } from '@wix/react-component-schema'
 import { CSS_PROPERTIES, ELEMENTS } from '@wix/react-component-schema'
 import { camelCase } from 'case-anything'
+import { buildRefElementManifestKey } from '../extensions/ref-elements/path-utils'
+import type { RefElementMatch } from '../extensions/ref-elements/types'
 import type { ComponentInfoWithCss } from '../index'
 import type { MatchedCssData, RegisteredCustomProperty } from '../information-extractors/css/types'
 import type {
@@ -21,8 +23,6 @@ import type {
   TrackingStores,
 } from '../information-extractors/react'
 import { getDefaultDisplayForTag, resolveDisplayValue } from '../information-extractors/react'
-import { buildRefElementManifestKey } from '../ref-elements/path-utils'
-import type { RefElementMatch } from '../ref-elements/types'
 import { findPreferredSemanticClass, normalizeClassNames } from '../utils/css-class'
 import { resolveLonghand } from './css-longhand-resolver'
 import { type CustomClassTrigger, buildCustomStatesBlock } from './custom-states-builder'

package/src/extensions/context-providers/context.test.ts

@@ -0,0 +1,181 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import ts from 'typescript'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { resolveModuleUrlFromEntryPath } from '../shared/module-resolution'
+import { buildContextProviderModules } from './context'
+
+const temporaryDirectoryPaths: string[] = []
+
+afterEach(() => {
+  for (const temporaryDirectoryPath of temporaryDirectoryPaths.splice(0)) {
+    fs.rmSync(temporaryDirectoryPath, { force: true, recursive: true })
+  }
+})
+
+const FORMAT_A_CATALOG_ENTRY = {
+  type: 'GenericExtension',
+  options: {
+    compType: 'EDITOR_CONTEXT_PROVIDER',
+    compData: {
+      editorContextProvider: {
+        context: { items: { title: { dataType: 'text' } } },
+        resources: {
+          contextSpecifier: {
+            hook: 'useEventContext',
+            moduleSpecifier: 'my-context-package/context-provider',
+          },
+          dependencies: { contextDependencies: [] },
+        },
+      },
+    },
+  },
+}
+
+const FORMAT_B_CATALOG_ENTRY = {
+  context: { items: { title: { dataType: 'text' } } },
+  resources: {
+    contextSpecifier: {
+      hook: 'useEventContext',
+      moduleSpecifier: 'my-context-package/context-provider',
+    },
+    dependencies: { contextDependencies: [] },
+  },
+}
+
+function createPackageSetup(options: {
+  extensionsContent: string
+  importSpecifier?: string
+}): { compiledEntryPath: string; sourceFilePath: string } {
+  const temporaryDirectoryPath = fs.mkdtempSync(path.join(os.tmpdir(), 'zero-config-context-provider-'))
+  temporaryDirectoryPaths.push(temporaryDirectoryPath)
+
+  const sourceFilePath = path.join(temporaryDirectoryPath, 'Component.tsx')
+  const compiledEntryPath = path.join(temporaryDirectoryPath, 'dist', 'index.js')
+  const packageDirectoryPath = path.join(temporaryDirectoryPath, 'node_modules', 'my-context-package')
+
+  fs.mkdirSync(path.dirname(compiledEntryPath), { recursive: true })
+  fs.mkdirSync(packageDirectoryPath, { recursive: true })
+
+  fs.writeFileSync(
+    sourceFilePath,
+    `import { useEventContext } from '${options.importSpecifier ?? 'my-context-package/context-provider'}'\nexport default function Component() { return null }\n`,
+  )
+  fs.writeFileSync(compiledEntryPath, 'export {}\n')
+  fs.writeFileSync(path.join(packageDirectoryPath, 'context-provider.js'), 'export function useEventContext() {}\n')
+  fs.writeFileSync(path.join(packageDirectoryPath, 'extensions.js'), options.extensionsContent)
+  fs.writeFileSync(
+    path.join(packageDirectoryPath, 'package.json'),
+    JSON.stringify(
+      {
+        name: 'my-context-package',
+        type: 'module',
+        exports: {
+          '.': './context-provider.js',
+          './context-provider': './context-provider.js',
+          './extensions': './extensions.js',
+        },
+      },
+      null,
+      2,
+    ),
+  )
+
+  return { compiledEntryPath, sourceFilePath }
+}
+
+function createProgram(sourceFilePath: string): ts.Program {
+  return ts.createProgram({
+    rootNames: [sourceFilePath],
+    options: {
+      allowJs: true,
+      jsx: ts.JsxEmit.ReactJSX,
+    },
+  })
+}
+
+describe('buildContextProviderModules', () => {
+  it('returns empty when the import is a bare package with no sub-path', async () => {
+    const { compiledEntryPath, sourceFilePath } = createPackageSetup({
+      importSpecifier: 'my-context-package',
+      extensionsContent: `export default [${JSON.stringify(FORMAT_A_CATALOG_ENTRY)}]\n`,
+    })
+    const program = createProgram(sourceFilePath)
+
+    const modules = await buildContextProviderModules(program, sourceFilePath, compiledEntryPath)
+
+    expect(modules).toEqual([])
+  })
+
+  it('resolves a context provider from a Format A catalog entry (manifest nested under options.compData.editorContextProvider)', async () => {
+    const { compiledEntryPath, sourceFilePath } = createPackageSetup({
+      extensionsContent: `export default [${JSON.stringify(FORMAT_A_CATALOG_ENTRY)}]\n`,
+    })
+    const program = createProgram(sourceFilePath)
+
+    const modules = await buildContextProviderModules(program, sourceFilePath, compiledEntryPath)
+
+    expect(modules).toEqual([
+      {
+        hookName: 'useEventContext',
+        moduleSpecifier: 'my-context-package/context-provider',
+        resolvedModuleUrl: resolveModuleUrlFromEntryPath(compiledEntryPath, 'my-context-package/context-provider'),
+        contextSchema: { items: { title: { dataType: 'text' } } },
+        contextDependencies: [],
+      },
+    ])
+  })
+
+  it('resolves a context provider from a Format B catalog entry (manifest at root)', async () => {
+    const { compiledEntryPath, sourceFilePath } = createPackageSetup({
+      extensionsContent: `export default [${JSON.stringify(FORMAT_B_CATALOG_ENTRY)}]\n`,
+    })
+    const program = createProgram(sourceFilePath)
+
+    const modules = await buildContextProviderModules(program, sourceFilePath, compiledEntryPath)
+
+    expect(modules).toEqual([
+      {
+        hookName: 'useEventContext',
+        moduleSpecifier: 'my-context-package/context-provider',
+        resolvedModuleUrl: resolveModuleUrlFromEntryPath(compiledEntryPath, 'my-context-package/context-provider'),
+        contextSchema: { items: { title: { dataType: 'text' } } },
+        contextDependencies: [],
+      },
+    ])
+  })
+
+  it('returns empty when the imported specifier does not match any catalog entry moduleSpecifier', async () => {
+    const nonMatchingEntry = {
+      ...FORMAT_B_CATALOG_ENTRY,
+      resources: {
+        ...FORMAT_B_CATALOG_ENTRY.resources,
+        contextSpecifier: {
+          hook: 'useOtherContext',
+          moduleSpecifier: 'my-context-package/other-module',
+        },
+      },
+    }
+    const { compiledEntryPath, sourceFilePath } = createPackageSetup({
+      extensionsContent: `export default [${JSON.stringify(nonMatchingEntry)}]\n`,
+    })
+    const program = createProgram(sourceFilePath)
+
+    const modules = await buildContextProviderModules(program, sourceFilePath, compiledEntryPath)
+
+    expect(modules).toEqual([])
+  })
+
+  it('throws when the extensions catalog throws during loading', async () => {
+    const { compiledEntryPath, sourceFilePath } = createPackageSetup({
+      extensionsContent: "throw new Error('broken catalog')\n",
+    })
+    const program = createProgram(sourceFilePath)
+
+    await expect(buildContextProviderModules(program, sourceFilePath, compiledEntryPath)).rejects.toThrow(
+      'broken catalog',
+    )
+  })
+})

package/src/extensions/context-providers/context.ts

@@ -0,0 +1,83 @@
+import type ts from 'typescript'
+import { collectAllPackageImportSpecifiers } from '../shared/ast-scanner'
+import { loadNormalizedCatalogEntries } from '../shared/catalog-loader'
+import { resolveModuleUrlFromEntryPath } from '../shared/module-resolution'
+import type { ContextProviderModule, ContextSchema } from './types'
+
+interface NormalizedContextProviderCatalogEntry {
+  hookName: string
+  moduleSpecifier: string
+  contextSchema: ContextSchema
+  contextDependencies: string[]
+}
+
+export async function buildContextProviderModules(
+  program: ts.Program,
+  sourceFilePath: string,
+  compiledEntryPath: string,
+): Promise<ContextProviderModule[]> {
+  const allImportedSpecifiers = collectAllPackageImportSpecifiers(program, sourceFilePath)
+  if (allImportedSpecifiers.length === 0) {
+    return []
+  }
+
+  const catalogEntries = await loadNormalizedCatalogEntries(
+    allImportedSpecifiers,
+    compiledEntryPath,
+    normalizeContextProviderEntry,
+  )
+
+  const importedSpecifierSet = new Set(allImportedSpecifiers)
+  const contextProviderModules: ContextProviderModule[] = []
+
+  for (const catalogEntry of catalogEntries) {
+    if (!importedSpecifierSet.has(catalogEntry.moduleSpecifier)) {
+      continue
+    }
+
+    const resolvedModuleUrl = resolveModuleUrlFromEntryPath(compiledEntryPath, catalogEntry.moduleSpecifier)
+    if (!resolvedModuleUrl) {
+      continue
+    }
+
+    contextProviderModules.push({
+      hookName: catalogEntry.hookName,
+      moduleSpecifier: catalogEntry.moduleSpecifier,
+      resolvedModuleUrl,
+      contextSchema: catalogEntry.contextSchema,
+      contextDependencies: catalogEntry.contextDependencies,
+    })
+  }
+
+  return contextProviderModules
+}
+
+type UnknownObject = Record<string, unknown> | undefined
+
+function normalizeContextProviderEntry(rawEntry: unknown): NormalizedContextProviderCatalogEntry | undefined {
+  if (rawEntry === null || typeof rawEntry !== 'object') {
+    return undefined
+  }
+
+  const entry = rawEntry as Record<string, unknown>
+  // Format A wraps the manifest under options.compData.editorContextProvider; Format B exports it at the root.
+  const compData = (entry.options as UnknownObject)?.compData as UnknownObject
+  const normalizedEntry = (compData?.editorContextProvider ?? entry) as Record<string, unknown>
+
+  const resources = normalizedEntry.resources as UnknownObject
+  const contextSpecifier = resources?.contextSpecifier as { hook?: string; moduleSpecifier?: string } | undefined
+
+  if (!contextSpecifier?.hook || !contextSpecifier?.moduleSpecifier) {
+    return undefined
+  }
+
+  const dependencies = resources?.dependencies as { contextDependencies?: string[] } | undefined
+  return {
+    hookName: contextSpecifier.hook,
+    moduleSpecifier: contextSpecifier.moduleSpecifier,
+    contextSchema: {
+      items: (normalizedEntry.context as ContextSchema | undefined)?.items ?? {},
+    },
+    contextDependencies: dependencies?.contextDependencies ?? [],
+  }
+}

package/src/extensions/context-providers/mock-provider.test.ts

@@ -0,0 +1,44 @@
+import React, { type ComponentType } from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import { buildContextAwareWrapper } from './mock-provider'
+
+function makeProvider(label: string): ComponentType<{ children?: React.ReactNode }> {
+  const Provider = ({ children }: { children?: React.ReactNode }) =>
+    React.createElement('div', { 'data-provider': label }, children)
+  return Provider
+}
+
+describe('buildContextAwareWrapper', () => {
+  it('places dependency providers outermost (topological sort)', () => {
+    // ticketProvider depends on eventProvider — eventProvider must render outermost
+    const loadedProviders = [
+      { moduleSpecifier: 'pkg/ticket', contextDependencies: ['pkg/event'], Provider: makeProvider('ticket') },
+      { moduleSpecifier: 'pkg/event', contextDependencies: [], Provider: makeProvider('event') },
+    ]
+
+    const identityWrapper = (Component: ComponentType<unknown>): ComponentType<unknown> => Component
+    const wrap = buildContextAwareWrapper(loadedProviders, identityWrapper, React)
+    const Inner: ComponentType<unknown> = () => React.createElement('span', null, 'content')
+    const html = renderToStaticMarkup(React.createElement(wrap(Inner), {}))
+
+    // event (the dependency) must appear before ticket in the HTML — it's the outer wrapper
+    expect(html.indexOf('data-provider="event"')).toBeLessThan(html.indexOf('data-provider="ticket"'))
+  })
+
+  it('composes options.wrapper as the outermost layer when provided', () => {
+    const customWrapper =
+      (Component: ComponentType<unknown>): ComponentType<unknown> =>
+      (props) =>
+        React.createElement('div', { 'data-wrapper': 'custom' }, React.createElement(Component, props as object))
+
+    const loadedProviders = [{ moduleSpecifier: 'pkg/event', contextDependencies: [], Provider: makeProvider('event') }]
+
+    const wrap = buildContextAwareWrapper(loadedProviders, customWrapper, React)
+    const Inner: ComponentType<unknown> = () => React.createElement('span', null, 'content')
+    const html = renderToStaticMarkup(React.createElement(wrap(Inner), {}))
+
+    expect(html.indexOf('data-wrapper="custom"')).toBeLessThan(html.indexOf('data-provider="event"'))
+    expect(html.indexOf('data-provider="event"')).toBeLessThan(html.indexOf('<span>'))
+  })
+})

package/src/extensions/context-providers/mock-provider.ts

@@ -0,0 +1,210 @@
+import type React from 'react'
+import type { ComponentType, Context } from 'react'
+import { generateMockContextValues } from '../../information-extractors/react/utils/mock-generator'
+import { computeSignedContextProviderUrl, ensureReactRuntimeLoader } from '../../react-runtime-loader'
+import type { RefElementModule } from '../ref-elements/types'
+import type { ContextProviderModule } from './types'
+
+type AnyFunction = (...args: unknown[]) => unknown
+
+interface ReactShim {
+  useContext(context: unknown): unknown
+  [hookName: string]: unknown
+}
+
+type GlobalWithReact = Record<symbol, ReactShim>
+
+// Hooks whose return value is consumed before useContext is reached — returning undefined would crash before the interceptor fires.
+const RETURN_VALUE_HOOK_STUBS: Record<string, AnyFunction> = {
+  useState: (initialState) => [
+    typeof initialState === 'function' ? (initialState as () => unknown)() : initialState,
+    () => {},
+  ],
+  useReducer: (_reducer, initialState, init) => [
+    typeof init === 'function' ? (init as (state: unknown) => unknown)(initialState) : initialState,
+    () => {},
+  ],
+  useRef: (initialValue) => ({ current: initialValue }),
+  useMemo: (factory) => {
+    try {
+      return (factory as () => unknown)()
+    } catch {
+      return undefined
+    }
+  },
+  useCallback: (callbackFn) => callbackFn,
+  useTransition: () => [false, () => {}],
+  useDeferredValue: (value) => value,
+  useSyncExternalStore: (_subscribe, getSnapshot) => (getSnapshot as () => unknown)(),
+}
+
+const genericHookStub: AnyFunction = () => undefined
+
+interface LoadedMockProvider {
+  moduleSpecifier: string
+  contextDependencies: string[]
+  Provider: ComponentType<{ children?: React.ReactNode }>
+}
+
+/**
+ * Builds a synthetic mock Provider for each context provider module, filled with
+ * schema-derived values. Identifies each context by calling the hook and intercepting
+ * `useContext` — intercepting `createContext` would require patching before the module
+ * loads, which fails when the module is already in the ESM cache.
+ *
+ * The loop is intentionally serial — each iteration patches a global and restores it in a
+ * finally block; concurrent iterations would interleave the patches.
+ */
+export async function loadMockProviders(
+  contextProviderModules: ContextProviderModule[],
+  reactInstance: typeof React,
+  refElementModules: RefElementModule[] = [],
+): Promise<LoadedMockProvider[]> {
+  ensureReactRuntimeLoader()
+
+  const loadedProviders: LoadedMockProvider[] = []
+
+  for (const contextProviderModule of contextProviderModules) {
+    const capturedContext = await captureHookContext(contextProviderModule, refElementModules)
+    if (!capturedContext) {
+      console.warn(
+        `Could not capture context for hook "${contextProviderModule.hookName}" from "${contextProviderModule.moduleSpecifier}" — skipping mock provider.`,
+      )
+      continue
+    }
+
+    const mockValues = generateMockContextValues(contextProviderModule.contextSchema)
+    const Provider = buildSyntheticProvider(capturedContext, mockValues, reactInstance)
+    loadedProviders.push({
+      moduleSpecifier: contextProviderModule.moduleSpecifier,
+      contextDependencies: contextProviderModule.contextDependencies,
+      Provider,
+    })
+  }
+
+  return loadedProviders
+}
+
+/** Providers that others depend on are placed outermost (applied last in the chain). */
+export function buildContextAwareWrapper(
+  loadedProviders: LoadedMockProvider[],
+  outerWrapper: (Component: ComponentType<unknown>) => ComponentType<unknown>,
+  reactInstance: typeof React,
+): (Component: ComponentType<unknown>) => ComponentType<unknown> {
+  const sortedProviders = sortProvidersByDependency(loadedProviders)
+
+  return (Component: ComponentType<unknown>): ComponentType<unknown> => {
+    const WrappedWithProviders: ComponentType<unknown> = (props) => {
+      let element = reactInstance.createElement(Component, props as Record<string, unknown>)
+
+      for (const { Provider } of sortedProviders) {
+        element = reactInstance.createElement(Provider, null, element)
+      }
+
+      return element as React.ReactElement
+    }
+    return outerWrapper(WrappedWithProviders)
+  }
+}
+
+async function captureHookContext(
+  contextProviderModule: ContextProviderModule,
+  refElementModules: RefElementModule[],
+): Promise<Context<unknown> | null> {
+  // Must use the same signed URL the statics bundle will use so both paths hit the same ESM cache entry.
+  const signedModuleUrl = computeSignedContextProviderUrl(contextProviderModule.resolvedModuleUrl, refElementModules)
+  const moduleExports = (await import(signedModuleUrl)) as Record<string, unknown>
+  const hookFn = moduleExports[contextProviderModule.hookName]
+  if (typeof hookFn !== 'function') {
+    return null
+  }
+
+  let capturedContext: Context<unknown> | null = null
+
+  const useContextInterceptor = (context: Context<unknown>) => {
+    // First useContext call wins — hooks in this system are expected to read exactly one context.
+    if (!capturedContext) {
+      capturedContext = context
+    }
+    // Return a truthy mock so any "must be used within a Provider" guard doesn't throw
+    return {} as unknown
+  }
+
+  const REACT_KEY = Symbol.for('zero-config:react-originals')
+  const shimReact = (globalThis as unknown as GlobalWithReact)[REACT_KEY]
+
+  if (!shimReact) {
+    throw new Error(
+      `React shim is not registered under Symbol.for('${REACT_KEY.description}') — ensure ensureReactRuntimeLoader() was called before loadMockProviders()`,
+    )
+  }
+
+  const originalUseContext = shimReact.useContext
+  shimReact.useContext = useContextInterceptor
+
+  const originalHooks: Record<string, unknown> = {}
+  for (const hookName of Object.keys(shimReact)) {
+    if (hookName !== 'useContext' && hookName.startsWith('use') && typeof shimReact[hookName] === 'function') {
+      originalHooks[hookName] = shimReact[hookName]
+      shimReact[hookName] = RETURN_VALUE_HOOK_STUBS[hookName] ?? genericHookStub
+    }
+  }
+
+  try {
+    ;(hookFn as () => unknown)()
+  } catch {
+    // Hook may throw after useContext fires (e.g. a "must be used within a Provider" guard) — capturedContext is already set.
+  } finally {
+    shimReact.useContext = originalUseContext
+    for (const [hookName, original] of Object.entries(originalHooks)) {
+      shimReact[hookName] = original
+    }
+  }
+
+  return capturedContext
+}
+
+function buildSyntheticProvider(
+  capturedContext: Context<unknown>,
+  mockValues: Record<string, unknown>,
+  reactInstance: typeof React,
+): ComponentType<{ children?: React.ReactNode }> {
+  return ({ children }: { children?: React.ReactNode }): React.ReactElement => {
+    return reactInstance.createElement(capturedContext.Provider, { value: mockValues }, children)
+  }
+}
+
+// Topological sort: dependency providers come last so they wrap outermost.
+function sortProvidersByDependency(providers: LoadedMockProvider[]): LoadedMockProvider[] {
+  const providerBySpecifier = new Map(providers.map((provider) => [provider.moduleSpecifier, provider]))
+  const visited = new Set<string>()
+  const sorted: LoadedMockProvider[] = []
+
+  function visit(moduleSpecifier: string): void {
+    if (visited.has(moduleSpecifier)) {
+      return
+    }
+    visited.add(moduleSpecifier)
+
+    const provider = providerBySpecifier.get(moduleSpecifier)
+    if (!provider) {
+      return
+    }
+
+    for (const dependency of provider.contextDependencies) {
+      if (providerBySpecifier.has(dependency)) {
+        visit(dependency)
+      }
+    }
+
+    sorted.push(provider)
+  }
+
+  for (const provider of providers) {
+    visit(provider.moduleSpecifier)
+  }
+
+  // Post-order DFS gives [dependency, dependent]. Reverse so dependencies come last
+  // in the loop below — last element applied is outermost in the React tree.
+  return sorted.reverse()
+}

package/src/extensions/context-providers/types.ts

@@ -0,0 +1,22 @@
+export interface ContextProviderModule {
+  hookName: string
+  moduleSpecifier: string
+  resolvedModuleUrl: string
+  contextSchema: ContextSchema
+  contextDependencies: string[]
+}
+
+export interface ContextSchema {
+  items: Record<string, ContextSchemaItem>
+}
+
+export interface ContextSchemaItem {
+  dataType: string
+  displayName?: string
+  data?: ContextSchema
+  arrayItems?: ContextArrayItems
+}
+
+export interface ContextArrayItems {
+  item?: ContextSchemaItem
+}

package/src/{ref-elements → extensions/ref-elements}/context.test.ts

@@ -4,9 +4,9 @@ import path from 'node:path'
 import ts from 'typescript'
 import { afterEach, describe, expect, it } from 'vitest'
 
-import type { ComponentInfo } from '../information-extractors/ts/types'
+import type { ComponentInfo } from '../../information-extractors/ts/types'
+import { resolveModuleUrlFromEntryPath } from '../shared/module-resolution'
 import { buildRefElementContext } from './context'
-import { resolveModuleUrlFromEntryPath } from './module-resolution'
 
 const temporaryDirectoryPaths: string[] = []
 const compiledEntryPath = path.resolve(__dirname, 'context.test.ts')
@@ -97,7 +97,7 @@ describe('buildRefElementContext', () => {
         componentName: 'Component',
         props: {},
       } satisfies ComponentInfo,
-      path.resolve(__dirname, '../__fixtures__/esm-ref-element-entry.mjs'),
+      path.resolve(__dirname, '../../__fixtures__/esm-ref-element-entry.mjs'),
     )
 
     expect(refElementContext.runtimeModules).toEqual([
@@ -105,7 +105,7 @@ describe('buildRefElementContext', () => {
         exportNames: ['default', 'BareRefButton'],
         moduleSpecifier: '@wix/zero-config-ref-element-fixtures/BareRefButton',
         resolvedModuleUrl: resolveModuleUrlFromEntryPath(
-          path.resolve(__dirname, '../__fixtures__/esm-ref-element-entry.mjs'),
+          path.resolve(__dirname, '../../__fixtures__/esm-ref-element-entry.mjs'),
           '@wix/zero-config-ref-element-fixtures/BareRefButton',
         ),
         refComponentType: 'wixEditorElements.BareRefButton',