@edgeone/vite-core 0.0.1-beta.1

package/dist/factory.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Adapter Factory - Simplifies the creation of framework adapters
+ *
+ * Provides factory functions and preset configurations to reduce boilerplate code
+ */
+import type { BuildContext, RouteInfo, FrameworkAdapter } from "./types.js";
+import { type RouteSource } from "./route-parser.js";
+/**
+ * Server wrapper preset configuration
+ */
+export interface ServerWrapperPreset {
+    imports?: string;
+    handlerSetup: string;
+    handlerCall: string;
+    requiresHtmlTemplate?: boolean;
+}
+/**
+ * Built-in server wrapper presets (generic, framework-agnostic)
+ *
+ * Note: All presets use `serverBuild` (namespace import) and `serverExports` (rest exports)
+ * which are automatically provided by generateServerWrapperCode()
+ *
+ * Framework-specific presets should be defined in their respective adapter packages.
+ */
+export declare const SERVER_WRAPPER_PRESETS: {
+    /** Generic handler - detects default or handler export */
+    readonly generic: {
+        readonly handlerSetup: string;
+        readonly handlerCall: "handler(webRequest, ...args)";
+    };
+    /** Hono style - supports app.fetch */
+    readonly hono: {
+        readonly handlerSetup: string;
+        readonly handlerCall: "serverHandler(webRequest, ...args)";
+    };
+    /** Vite SSR - standard Vite SSR with render function */
+    readonly viteSSR: {
+        readonly requiresHtmlTemplate: true;
+        readonly handlerSetup: string;
+        readonly handlerCall: "handleSSRRequest(webRequest)";
+    };
+};
+/**
+ * Build directory configuration
+ */
+export interface BuildDirConfig {
+    client: string[];
+    server?: string[];
+}
+/**
+ * Route source configuration for declarative route parsing
+ */
+export interface RouteSourceConfig {
+    /** Route sources to try in order */
+    sources?: RouteSource[];
+    /** Default routes if no sources match */
+    defaultRoutes?: string[];
+    /** Extra routes to add in SSR mode */
+    ssrExtraRoutes?: string[];
+    /** Transform function for parsed routes */
+    transform?: (routes: RouteInfo[], context: BuildContext) => RouteInfo[];
+}
+/**
+ * esbuild configuration for server bundling
+ */
+export interface EsbuildConfig {
+    /** Working directory for esbuild */
+    absWorkingDir?: string | ((context: BuildContext) => string);
+    /** External modules */
+    external?: string[];
+    /** Additional esbuild options */
+    options?: Record<string, unknown>;
+}
+/**
+ * Adapter factory configuration
+ */
+export interface AdapterFactoryConfig {
+    name: string;
+    configFiles: string[];
+    buildDirs: BuildDirConfig;
+    serverEntryFiles?: string[];
+    serverWrapper?: keyof typeof SERVER_WRAPPER_PRESETS | ServerWrapperPreset;
+    /** Declarative route configuration */
+    routeConfig?: RouteSourceConfig;
+    /** Legacy: default routes (use routeConfig.defaultRoutes instead) */
+    defaultRoutes?: string[];
+    /** Legacy: SSR extra routes (use routeConfig.ssrExtraRoutes instead) */
+    ssrExtraRoutes?: string[];
+    ssr404?: boolean | ((isSSR: boolean) => boolean);
+    htmlTemplatePaths?: string[];
+    /** esbuild configuration */
+    esbuildConfig?: EsbuildConfig;
+}
+/**
+ * Adapter factory runtime options
+ */
+export interface AdapterFactoryOptions {
+    clientBuildDir?: string;
+    serverBuildDir?: string;
+    serverEntry?: string;
+    routes?: string[];
+}
+/**
+ * Create a framework adapter
+ */
+export declare function createFrameworkAdapter(config: AdapterFactoryConfig, options?: AdapterFactoryOptions, overrides?: Partial<FrameworkAdapter>): FrameworkAdapter;
+/**
+ * Create a stateful adapter (for complex adapters needing shared state)
+ */
+export declare function createStatefulAdapter<TState extends object>(initialState: TState, factory: (state: TState) => FrameworkAdapter): FrameworkAdapter;
+/**
+ * Result of extending server wrapper presets
+ */
+export interface ExtendedPresetsResult<TCustom extends Record<string, ServerWrapperPreset>> {
+    /** Extended presets object (core + custom) */
+    presets: typeof SERVER_WRAPPER_PRESETS & TCustom;
+    /** Type-safe preset resolver function */
+    resolvePreset: (preset: keyof (typeof SERVER_WRAPPER_PRESETS & TCustom) | ServerWrapperPreset) => ServerWrapperPreset;
+    /** Get all available preset names */
+    getPresetNames: () => (keyof (typeof SERVER_WRAPPER_PRESETS & TCustom))[];
+}
+/**
+ * Create a server wrapper preset
+ *
+ * Helper function to create a properly typed preset with validation and normalization.
+ * Automatically trims handlerSetup and validates required fields.
+ *
+ * @example
+ * ```ts
+ * const myPreset = createServerWrapperPreset({
+ *   imports: `import { handler } from 'my-framework';`,
+ *   handlerSetup: `const requestHandler = handler(serverExports);`,
+ *   handlerCall: "requestHandler(webRequest)",
+ * });
+ * ```
+ */
+export declare function createServerWrapperPreset(config: ServerWrapperPreset): ServerWrapperPreset;
+/**
+ * Extend core server wrapper presets with custom presets
+ *
+ * This utility provides a standardized way for adapters to:
+ * 1. Add framework-specific presets while keeping core presets
+ * 2. Get a type-safe resolver function
+ * 3. Export extended presets for external use
+ *
+ * Custom presets are automatically validated and normalized using createServerWrapperPreset().
+ *
+ * @example
+ * ```ts
+ * // In vite-adapter - can pass raw config, will be validated automatically
+ * const { presets, resolvePreset } = extendServerWrapperPresets({
+ *   vike: {
+ *     imports: `import { renderPage } from 'vike/server';`,
+ *     handlerSetup: `...`,
+ *     handlerCall: "handleVikeRequest(webRequest)",
+ *   },
+ * });
+ *
+ * export const SERVER_WRAPPER_PRESETS = presets;
+ * export type ServerWrapperPresetName = keyof typeof presets;
+ *
+ * // Use in adapter
+ * const resolved = resolvePreset(options.serverWrapper || "viteSSR");
+ * ```
+ */
+export declare function extendServerWrapperPresets<TCustom extends Record<string, ServerWrapperPreset>>(customPresets: TCustom): ExtendedPresetsResult<TCustom>;
+/**
+ * Combine multiple detector functions (returns true if any matches)
+ */
+export declare function combineDetectors(...detectors: ((context: BuildContext) => Promise<boolean> | boolean)[]): (context: BuildContext) => Promise<boolean>;
+/**
+ * Create detector based on config files
+ */
+export declare function createConfigDetector(configFiles: string[]): (context: BuildContext) => Promise<boolean>;
+/**
+ * Create detector based on build directories
+ */
+export declare function createBuildDirDetector(buildDirs: string[]): (context: BuildContext) => Promise<boolean>;
+/**
+ * Create detector based on package.json dependencies
+ */
+export declare function createDependencyDetector(dependencies: string[]): (context: BuildContext) => Promise<boolean>;
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"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"}

package/dist/factory.js

@@ -0,0 +1,482 @@
+/**
+ * Adapter Factory - Simplifies the creation of framework adapters
+ *
+ * Provides factory functions and preset configurations to reduce boilerplate code
+ */
+import path from "path";
+import { pathExists, readFile, detectConfigFile, detectBuildDir, detectServerEntry, generateServerWrapperCode, createDefaultMeta, logBuildArtifacts, } from "./utils.js";
+import { ViteConfigParser, } from "./vite-config-parser.js";
+import { parseRoutesFromSources, } from "./route-parser.js";
+/**
+ * Built-in server wrapper presets (generic, framework-agnostic)
+ *
+ * Note: All presets use `serverBuild` (namespace import) and `serverExports` (rest exports)
+ * which are automatically provided by generateServerWrapperCode()
+ *
+ * Framework-specific presets should be defined in their respective adapter packages.
+ */
+export const SERVER_WRAPPER_PRESETS = {
+    /** Generic handler - detects default or handler export */
+    generic: {
+        handlerSetup: `
+const handler = typeof defaultExport === 'function' 
+  ? defaultExport 
+  : (typeof serverExports.handler === 'function' ? serverExports.handler : null);
+
+if (!handler) {
+  throw new Error('No handler found in server build');
+}`.trim(),
+        handlerCall: "handler(webRequest, ...args)",
+    },
+    /** Hono style - supports app.fetch */
+    hono: {
+        handlerSetup: `
+const getHandler = () => {
+  if (typeof defaultExport === 'function') return defaultExport;
+  if (typeof serverExports.fetch === 'function') return serverExports.fetch;
+  if (typeof serverExports.app === 'object' && typeof serverExports.app.fetch === 'function') {
+    return serverExports.app.fetch.bind(serverExports.app);
+  }
+  throw new Error('No handler found in server build');
+};
+const serverHandler = getHandler();`.trim(),
+        handlerCall: "serverHandler(webRequest, ...args)",
+    },
+    /** Vite SSR - standard Vite SSR with render function */
+    viteSSR: {
+        requiresHtmlTemplate: true,
+        handlerSetup: `
+const renderFn = typeof serverExports.render === 'function' 
+  ? serverExports.render 
+  : (typeof defaultExport === 'function' ? defaultExport : null);
+
+if (!renderFn) {
+  throw new Error('No render function found in server build. Expected export: render(url)');
+}
+
+async function handleSSRRequest(request) {
+  const url = new URL(request.url);
+  const pathname = url.pathname;
+  
+  try {
+    const rendered = await renderFn(pathname);
+    let html = __HTML_TEMPLATE__
+      .replace('<!--app-head-->', rendered.head ?? '')
+      .replace('<!--app-html-->', rendered.html ?? '');
+    
+    return new Response(html, {
+      status: 200,
+      headers: { 'Content-Type': 'text/html; charset=utf-8' }
+    });
+  } catch (error) {
+    console.error('SSR render error:', error);
+    return new Response('Internal Server Error: ' + error.message, {
+      status: 500,
+      headers: { 'Content-Type': 'text/plain' }
+    });
+  }
+}`.trim(),
+        handlerCall: "handleSSRRequest(webRequest)",
+    },
+};
+// ============================================================================
+// Internal Helper Functions
+// ============================================================================
+/**
+ * Create default detect function based on config files
+ */
+function createDefaultDetector(configFiles) {
+    return async (context) => {
+        const configPath = await detectConfigFile(context.projectRoot, configFiles);
+        return configPath !== null;
+    };
+}
+/**
+ * Create default getBuildArtifacts function
+ * Uses ViteConfigParser for comprehensive Vite config support:
+ * - build.outDir: custom output directory
+ * - build.assetsDir: static assets directory name
+ * - build.ssr: SSR entry point
+ * - build.manifest: manifest.json generation
+ * - base: public base path
+ * - rollupOptions.input: entry file(s)
+ * - rollupOptions.output.dir: output directory override
+ * - rollupOptions.output.entryFileNames: output filename pattern
+ * - rollupOptions.output.assetFileNames: asset filename pattern
+ * - rollupOptions.output.chunkFileNames: chunk filename pattern
+ */
+function createDefaultBuildArtifactsGetter(name, buildDirs, serverEntryFiles, options) {
+    const { clientBuildDir, serverBuildDir, serverEntry } = options;
+    return async (context) => {
+        const { projectRoot, isSSR, logger, viteConfig } = context;
+        // Resolve client directory
+        let clientDir = null;
+        if (clientBuildDir) {
+            clientDir = path.join(projectRoot, clientBuildDir);
+        }
+        else {
+            clientDir = await detectBuildDir(projectRoot, buildDirs.client);
+        }
+        let serverDir = null;
+        let serverEntryPath = null;
+        if (isSSR && buildDirs.server) {
+            // Use ViteConfigParser for comprehensive config support
+            if (viteConfig) {
+                const configParser = new ViteConfigParser(viteConfig, projectRoot, {
+                    logger,
+                    serverEntryCandidates: serverEntryFiles,
+                });
+                // Priority 1: Explicit serverBuildDir option
+                if (serverBuildDir) {
+                    serverDir = path.join(projectRoot, serverBuildDir);
+                }
+                else {
+                    // Priority 2: Get from Vite config using parser
+                    serverDir = configParser.getServerDir();
+                }
+                // Priority 3: Fall back to predefined build directories
+                if (!serverDir) {
+                    serverDir = await detectBuildDir(projectRoot, buildDirs.server);
+                }
+                // Find server entry
+                if (serverEntry) {
+                    // Explicit server entry path provided
+                    serverEntryPath = path.join(projectRoot, serverEntry);
+                }
+                else if (serverDir) {
+                    // Priority 1: Try to get server entry from Vite config using parser
+                    serverEntryPath = await configParser.findServerEntry(serverDir);
+                    if (serverEntryPath) {
+                        logger.verbose(`Using server entry from Vite config: ${serverEntryPath}`);
+                    }
+                    // Priority 2: Fall back to file detection with recursive search
+                    if (!serverEntryPath) {
+                        serverEntryPath = await detectServerEntry(serverDir, serverEntryFiles, {
+                            recursive: true,
+                            logger,
+                        });
+                    }
+                }
+            }
+            else {
+                // No Vite config available, use fallback detection
+                if (serverBuildDir) {
+                    serverDir = path.join(projectRoot, serverBuildDir);
+                }
+                else {
+                    serverDir = await detectBuildDir(projectRoot, buildDirs.server);
+                }
+                if (serverEntry) {
+                    serverEntryPath = path.join(projectRoot, serverEntry);
+                }
+                else if (serverDir) {
+                    serverEntryPath = await detectServerEntry(serverDir, serverEntryFiles, {
+                        recursive: true,
+                        logger,
+                    });
+                }
+            }
+        }
+        logBuildArtifacts(logger, name, {
+            clientDir,
+            serverDir,
+            serverEntry: serverEntryPath,
+        });
+        return {
+            clientDir,
+            serverDir,
+            serverEntry: serverEntryPath,
+            assetsDir: clientDir,
+        };
+    };
+}
+/**
+ * Create generateRoutes hook
+ */
+function createGenerateRoutesHook(effectiveRouteConfig, fallbackRoutes) {
+    return async (context) => {
+        const { projectRoot, isSSR, logger } = context;
+        // Try declarative route sources first
+        if (effectiveRouteConfig.sources && effectiveRouteConfig.sources.length > 0) {
+            let parsedRoutes = await parseRoutesFromSources(projectRoot, effectiveRouteConfig.sources, { isSSR, logger });
+            if (parsedRoutes.length > 0) {
+                // Apply transform if provided
+                if (effectiveRouteConfig.transform) {
+                    parsedRoutes = effectiveRouteConfig.transform(parsedRoutes, context);
+                }
+                // Add SSR extra routes
+                if (isSSR && effectiveRouteConfig.ssrExtraRoutes) {
+                    effectiveRouteConfig.ssrExtraRoutes.forEach((route) => {
+                        parsedRoutes.push({ path: route, isStatic: false, srcRoute: route });
+                    });
+                }
+                return parsedRoutes;
+            }
+        }
+        // Fallback to static route list
+        const routeList = fallbackRoutes.map((route) => ({
+            path: route,
+            isStatic: !isSSR,
+            srcRoute: route,
+        }));
+        if (isSSR && effectiveRouteConfig.ssrExtraRoutes) {
+            effectiveRouteConfig.ssrExtraRoutes.forEach((route) => {
+                routeList.push({ path: route, isStatic: false, srcRoute: route });
+            });
+        }
+        return routeList;
+    };
+}
+/**
+ * Create generateMeta hook
+ */
+function createGenerateMetaHook(ssr404) {
+    return async (context, routeList) => {
+        const meta = createDefaultMeta(routeList, { isSSR: context.isSSR });
+        if (ssr404 !== undefined) {
+            meta.conf.ssr404 = typeof ssr404 === "function"
+                ? ssr404(context.isSSR)
+                : ssr404;
+        }
+        return meta;
+    };
+}
+/**
+ * Create generateServerWrapper hook
+ */
+function createGenerateServerWrapperHook(wrapperConfig, htmlTemplatePaths) {
+    return async (context, wrapperCfg) => {
+        let handlerSetup = wrapperConfig.handlerSetup;
+        if (wrapperConfig.requiresHtmlTemplate) {
+            const { projectRoot, outputDir, logger } = context;
+            let htmlTemplate = "";
+            const templateCandidates = [
+                ...htmlTemplatePaths.map(p => path.join(projectRoot, p)),
+                path.join(projectRoot, outputDir, "assets/index.html"),
+            ];
+            for (const templatePath of templateCandidates) {
+                if (await pathExists(templatePath)) {
+                    htmlTemplate = await readFile(templatePath);
+                    logger.verbose(`Found HTML template: ${templatePath}`);
+                    break;
+                }
+            }
+            if (!htmlTemplate) {
+                logger.warn("HTML template not found, using default template");
+                htmlTemplate = "<!DOCTYPE html><html><head><!--app-head--></head><body><div id=\"app\"><!--app-html--></div></body></html>";
+            }
+            const escapedTemplate = JSON.stringify(htmlTemplate);
+            handlerSetup = `const __HTML_TEMPLATE__ = ${escapedTemplate};\n\n${handlerSetup}`;
+        }
+        return generateServerWrapperCode({
+            serverEntryPath: wrapperCfg.serverEntryPath,
+            imports: wrapperConfig.imports,
+            handlerSetup,
+            handlerCall: wrapperConfig.handlerCall,
+        });
+    };
+}
+/**
+ * Create beforeBundle hook if esbuildConfig is provided
+ */
+function createBeforeBundleHook(esbuildConfig) {
+    return async (context, bundleConfig) => {
+        const absWorkingDir = typeof esbuildConfig.absWorkingDir === "function"
+            ? esbuildConfig.absWorkingDir(context)
+            : esbuildConfig.absWorkingDir;
+        return {
+            ...bundleConfig,
+            external: esbuildConfig.external || bundleConfig.external,
+            esbuildOptions: {
+                ...bundleConfig.esbuildOptions,
+                ...esbuildConfig.options,
+                ...(absWorkingDir ? { absWorkingDir } : {}),
+            },
+        };
+    };
+}
+// ============================================================================
+// Main Factory Function
+// ============================================================================
+/**
+ * Create a framework adapter
+ */
+export function createFrameworkAdapter(config, options = {}, overrides) {
+    const { name, configFiles, buildDirs, serverEntryFiles = ["index.js", "index.mjs", "entry.js", "main.js"], serverWrapper = "generic", routeConfig, defaultRoutes = ["/"], ssrExtraRoutes = [], ssr404, htmlTemplatePaths = ["dist/client/index.html", "dist/index.html"], esbuildConfig, } = config;
+    const { routes = routeConfig?.defaultRoutes || defaultRoutes } = options;
+    // Merge route config with legacy options
+    const effectiveRouteConfig = {
+        sources: routeConfig?.sources,
+        defaultRoutes: routeConfig?.defaultRoutes || defaultRoutes,
+        ssrExtraRoutes: routeConfig?.ssrExtraRoutes || ssrExtraRoutes,
+        transform: routeConfig?.transform,
+    };
+    const wrapperConfig = typeof serverWrapper === "string"
+        ? SERVER_WRAPPER_PRESETS[serverWrapper]
+        : serverWrapper;
+    // Build adapter using helper functions
+    const baseAdapter = {
+        name,
+        detect: createDefaultDetector(configFiles),
+        getBuildArtifacts: createDefaultBuildArtifactsGetter(name, buildDirs, serverEntryFiles, options),
+        hooks: {
+            generateRoutes: createGenerateRoutesHook(effectiveRouteConfig, routes),
+            generateMeta: createGenerateMetaHook(ssr404),
+            generateServerWrapper: createGenerateServerWrapperHook(wrapperConfig, htmlTemplatePaths),
+            ...(esbuildConfig ? { beforeBundle: createBeforeBundleHook(esbuildConfig) } : {}),
+        },
+    };
+    if (overrides) {
+        return {
+            ...baseAdapter,
+            ...overrides,
+            name: overrides.name || baseAdapter.name,
+            hooks: { ...baseAdapter.hooks, ...overrides.hooks },
+        };
+    }
+    return baseAdapter;
+}
+/**
+ * Create a stateful adapter (for complex adapters needing shared state)
+ */
+export function createStatefulAdapter(initialState, factory) {
+    return factory({ ...initialState });
+}
+/**
+ * Create a server wrapper preset
+ *
+ * Helper function to create a properly typed preset with validation and normalization.
+ * Automatically trims handlerSetup and validates required fields.
+ *
+ * @example
+ * ```ts
+ * const myPreset = createServerWrapperPreset({
+ *   imports: `import { handler } from 'my-framework';`,
+ *   handlerSetup: `const requestHandler = handler(serverExports);`,
+ *   handlerCall: "requestHandler(webRequest)",
+ * });
+ * ```
+ */
+export function createServerWrapperPreset(config) {
+    if (!config.handlerSetup) {
+        throw new Error("Server wrapper preset must have handlerSetup");
+    }
+    if (!config.handlerCall) {
+        throw new Error("Server wrapper preset must have handlerCall");
+    }
+    return {
+        imports: config.imports,
+        handlerSetup: config.handlerSetup.trim(),
+        handlerCall: config.handlerCall,
+        requiresHtmlTemplate: config.requiresHtmlTemplate,
+    };
+}
+/**
+ * Extend core server wrapper presets with custom presets
+ *
+ * This utility provides a standardized way for adapters to:
+ * 1. Add framework-specific presets while keeping core presets
+ * 2. Get a type-safe resolver function
+ * 3. Export extended presets for external use
+ *
+ * Custom presets are automatically validated and normalized using createServerWrapperPreset().
+ *
+ * @example
+ * ```ts
+ * // In vite-adapter - can pass raw config, will be validated automatically
+ * const { presets, resolvePreset } = extendServerWrapperPresets({
+ *   vike: {
+ *     imports: `import { renderPage } from 'vike/server';`,
+ *     handlerSetup: `...`,
+ *     handlerCall: "handleVikeRequest(webRequest)",
+ *   },
+ * });
+ *
+ * export const SERVER_WRAPPER_PRESETS = presets;
+ * export type ServerWrapperPresetName = keyof typeof presets;
+ *
+ * // Use in adapter
+ * const resolved = resolvePreset(options.serverWrapper || "viteSSR");
+ * ```
+ */
+export function extendServerWrapperPresets(customPresets) {
+    // Validate and normalize all custom presets
+    const normalizedCustomPresets = {};
+    for (const [key, preset] of Object.entries(customPresets)) {
+        normalizedCustomPresets[key] =
+            createServerWrapperPreset(preset);
+    }
+    const extendedPresets = {
+        ...SERVER_WRAPPER_PRESETS,
+        ...normalizedCustomPresets,
+    };
+    function resolvePreset(preset) {
+        if (typeof preset === "string") {
+            const resolved = extendedPresets[preset];
+            if (!resolved) {
+                throw new Error(`Unknown server wrapper preset: "${preset}". Available presets: ${Object.keys(extendedPresets).join(", ")}`);
+            }
+            return resolved;
+        }
+        // Validate and normalize inline preset
+        return createServerWrapperPreset(preset);
+    }
+    function getPresetNames() {
+        return Object.keys(extendedPresets);
+    }
+    return {
+        presets: extendedPresets,
+        resolvePreset,
+        getPresetNames,
+    };
+}
+/**
+ * Combine multiple detector functions (returns true if any matches)
+ */
+export function combineDetectors(...detectors) {
+    return async (context) => {
+        for (const detector of detectors) {
+            if (await detector(context)) {
+                return true;
+            }
+        }
+        return false;
+    };
+}
+/**
+ * Create detector based on config files
+ */
+export function createConfigDetector(configFiles) {
+    return async (context) => {
+        return (await detectConfigFile(context.projectRoot, configFiles)) !== null;
+    };
+}
+/**
+ * Create detector based on build directories
+ */
+export function createBuildDirDetector(buildDirs) {
+    return async (context) => {
+        return (await detectBuildDir(context.projectRoot, buildDirs)) !== null;
+    };
+}
+/**
+ * Create detector based on package.json dependencies
+ */
+export function createDependencyDetector(dependencies) {
+    return async (context) => {
+        const packageJsonPath = path.join(context.projectRoot, "package.json");
+        if (!await pathExists(packageJsonPath))
+            return false;
+        try {
+            const content = await readFile(packageJsonPath);
+            const packageJson = JSON.parse(content);
+            const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+            return dependencies.some((dep) => dep in deps);
+        }
+        catch (error) {
+            context.logger?.verbose?.(`Failed to parse package.json: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    };
+}
+//# sourceMappingURL=factory.js.map