@ecopages/core 0.2.0-alpha.22 → 0.2.0-alpha.24

package/src/route-renderer/page-loading/dependency-resolver.js

@@ -1,444 +0,0 @@
-import path from "node:path";
-import { readFileSync } from "node:fs";
-import { rapidhash } from "../../utils/hash.js";
-import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
-import { normalizeModuleDeclarations } from "../../eco/module-dependencies.js";
-import { parseSync } from "oxc-parser";
-const DEPENDENCY_ERRORS = {
-  INVALID_STYLESHEET_ENTRY: "Invalid stylesheet dependency entry: expected src or content",
-  INVALID_SCRIPT_ENTRY: "Invalid script dependency entry: expected src or content",
-  LAZY_SCRIPT_MISSING_SRC: "Lazy script dependency entry in dependencies.scripts requires a src value"
-};
-function extractEcopagesVirtualImports(file) {
-  let source;
-  try {
-    source = readFileSync(file, "utf-8");
-  } catch {
-    return [];
-  }
-  let result;
-  try {
-    result = parseSync(file, source, { sourceType: "module" });
-  } catch {
-    return [];
-  }
-  const found = /* @__PURE__ */ new Map();
-  for (const node of result.program.body ?? []) {
-    if (node.type !== "ImportDeclaration") continue;
-    if (node.importKind === "type") continue;
-    const specifier = node.source?.value ?? "";
-    if (!specifier.startsWith("ecopages:")) continue;
-    if (found.get(specifier) === null) {
-      continue;
-    }
-    const namedImports = [];
-    for (const spec of node.specifiers ?? []) {
-      if (spec.type === "ImportSpecifier") {
-        let importedName = spec.local?.name;
-        if (spec.imported?.type === "Identifier") {
-          importedName = spec.imported.name;
-        } else if (spec.imported?.type === "Literal") {
-          importedName = spec.imported.value;
-        }
-        namedImports.push(importedName);
-      }
-    }
-    if (namedImports.length === 0) {
-      found.set(specifier, null);
-      continue;
-    }
-    const existing = found.get(specifier);
-    if (!existing) {
-      found.set(specifier, new Set(namedImports));
-      continue;
-    }
-    for (const imported of namedImports) {
-      existing.add(imported);
-    }
-  }
-  return Array.from(found.entries()).map(([from, importsSet]) => ({
-    from,
-    imports: importsSet ? Array.from(importsSet) : void 0
-  }));
-}
-function createModuleScriptName(from, imports) {
-  const normalizedImports = imports ? [...imports].sort().join(",") : "*";
-  const hash = rapidhash(`${from}|${normalizedImports}`).toString(16);
-  return `module-${hash}`;
-}
-function createNamedImportModuleSource(from, imports) {
-  const namedImports = [...new Set(imports)].sort().join(", ");
-  return `export { ${namedImports} } from '${from}';`;
-}
-function createNamespaceImportModuleSource(from) {
-  return `export * from '${from}';`;
-}
-function resolveDependencyPath(componentDir, pathUrl) {
-  return path.join(componentDir, pathUrl);
-}
-function isDependencyEntryObject(entry) {
-  return typeof entry === "object" && entry !== null;
-}
-function getDependencyEntrySrc(entry) {
-  return isDependencyEntryObject(entry) ? entry.src : entry;
-}
-function getDependencyEntryContent(entry) {
-  return isDependencyEntryObject(entry) ? entry.content : void 0;
-}
-function getDependencyEntryAttributes(entry) {
-  return isDependencyEntryObject(entry) ? entry.attributes : void 0;
-}
-function getDependencyEntrySrcOrThrow(entry, errorMessage) {
-  const src = getDependencyEntrySrc(entry);
-  if (!src) {
-    throw new Error(errorMessage);
-  }
-  return src;
-}
-function getLazyTriggerKey(lazy) {
-  if ("on:idle" in lazy) {
-    return "on:idle";
-  }
-  if ("on:interaction" in lazy) {
-    return `on:interaction:${lazy["on:interaction"]}`;
-  }
-  if ("on:visible" in lazy) {
-    const value = lazy["on:visible"];
-    return `on:visible:${value === true ? "true" : value}`;
-  }
-  return JSON.stringify(lazy);
-}
-function resolveLazyScripts(appConfig, componentDir, scripts) {
-  const getSafeFileName = (filepath) => {
-    const EXTENSIONS_TO_JS = ["ts", "tsx"];
-    const safe = filepath.replace(new RegExp(`\\.(${EXTENSIONS_TO_JS.join("|")})$`), ".js");
-    return safe.startsWith("./") ? safe.slice(2) : safe;
-  };
-  const baseDir = componentDir.split(appConfig.srcDir)[1] ?? "";
-  const resolvedPaths = scripts.map((script) => {
-    const relativePath = [AssetFactory.RESOLVED_ASSETS_DIR, baseDir, getSafeFileName(script)].filter(Boolean).join("/").replace(/\/+/g, "/");
-    return `/${relativePath.replace(/^\/+/, "")}`;
-  });
-  return resolvedPaths.join(",");
-}
-function buildResolvedLazyTriggers(config, groups) {
-  if (groups.length === 0) return [];
-  const componentFile = config.__eco?.file ?? "";
-  const sortedUrls = groups.flatMap((group) => group.scripts).sort().join(",");
-  const triggerId = `eco-trigger-${rapidhash(`${componentFile}:${sortedUrls}`).toString(16)}`;
-  const rules = groups.map((group) => {
-    const { scripts, lazy } = group;
-    if ("on:idle" in lazy) {
-      return { "on:idle": { scripts } };
-    }
-    if ("on:interaction" in lazy) {
-      return { "on:interaction": { value: lazy["on:interaction"], scripts } };
-    }
-    if ("on:visible" in lazy) {
-      const visibleSelector = lazy["on:visible"];
-      if (visibleSelector === true) return { "on:visible": { scripts } };
-      return { "on:visible": { value: String(visibleSelector), scripts } };
-    }
-    throw new Error(`Unknown lazy trigger kind: ${JSON.stringify(lazy)}`);
-  });
-  return [{ triggerId, rules }];
-}
-class DependencyResolverService {
-  appConfig;
-  assetProcessingService;
-  /**
-   * Creates the dependency resolver used by route and component rendering.
-   *
-   * @remarks
-   * The resolver stays intentionally separate from HTML rendering so component
-   * dependency collection, lazy trigger grouping, and processed-asset generation
-   * can evolve without changing renderer implementations.
-   */
-  constructor(appConfig, assetProcessingService) {
-    this.appConfig = appConfig;
-    this.assetProcessingService = assetProcessingService;
-  }
-  /**
-   * Resolves one dependency path relative to the component that declared it.
-   */
-  resolveDependencyPath(componentDir, pathUrl) {
-    return resolveDependencyPath(componentDir, pathUrl);
-  }
-  /**
-   * Maps lazy script source entries to deterministic fallback public URLs
-   * used when bundling output URLs are unavailable.
-   */
-  resolveLazyScripts(componentDir, scripts) {
-    return resolveLazyScripts(this.appConfig, componentDir, scripts);
-  }
-  /**
-   * Collects and processes component dependencies (styles, scripts, modules, lazy scripts).
-   * Lazy dependencies are always resolved into global-injector trigger maps.
-   */
-  async processComponentDependencies(components, integrationName) {
-    if (!this.assetProcessingService?.processDependencies) return [];
-    const dependencies = [];
-    const lazyScriptsByConfig = /* @__PURE__ */ new Map();
-    const lazyDependencyKeys = /* @__PURE__ */ new Set();
-    for (const component of components) {
-      if (!component) continue;
-      const componentFile = component.config?.__eco?.file;
-      if (!componentFile) continue;
-      const stylesheetDependencyKeys = /* @__PURE__ */ new Set();
-      const scriptDependencyKeys = /* @__PURE__ */ new Set();
-      const modulesMap = /* @__PURE__ */ new Map();
-      const collect = (config) => {
-        if (!config) return;
-        const file = config.__eco?.file;
-        if (!file) return;
-        const dir = path.dirname(file);
-        const dependenciesConfig = config.dependencies;
-        const registerLazyScript = ({
-          lazy,
-          lazyKey,
-          fallbackUrl
-        }) => {
-          let grouped = lazyScriptsByConfig.get(config);
-          if (!grouped) {
-            grouped = /* @__PURE__ */ new Map();
-            lazyScriptsByConfig.set(config, grouped);
-          }
-          const triggerKey = getLazyTriggerKey(lazy);
-          const existing = grouped.get(triggerKey) ?? { lazy, scripts: [] };
-          existing.scripts.push({ lazyKey, fallbackUrl });
-          grouped.set(triggerKey, existing);
-        };
-        if (dependenciesConfig?.stylesheets) {
-          for (const style of dependenciesConfig.stylesheets) {
-            const content = getDependencyEntryContent(style);
-            const src = getDependencyEntrySrc(style);
-            const attributes = getDependencyEntryAttributes(style);
-            if (content) {
-              const depKey2 = `style:content:${content}:${JSON.stringify(attributes ?? {})}`;
-              if (stylesheetDependencyKeys.has(depKey2)) {
-                continue;
-              }
-              stylesheetDependencyKeys.add(depKey2);
-              dependencies.push(
-                AssetFactory.createContentStylesheet({
-                  content,
-                  position: "head",
-                  attributes
-                })
-              );
-              continue;
-            }
-            if (!src) {
-              throw new Error(DEPENDENCY_ERRORS.INVALID_STYLESHEET_ENTRY);
-            }
-            const resolvedPath = resolveDependencyPath(dir, src);
-            const depKey = `style:file:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
-            if (stylesheetDependencyKeys.has(depKey)) {
-              continue;
-            }
-            stylesheetDependencyKeys.add(depKey);
-            dependencies.push(
-              AssetFactory.createFileStylesheet({
-                filepath: resolvedPath,
-                position: "head",
-                attributes: {
-                  rel: "stylesheet",
-                  ...attributes
-                }
-              })
-            );
-          }
-        }
-        if (dependenciesConfig?.scripts) {
-          for (const script of dependenciesConfig.scripts) {
-            if (isDependencyEntryObject(script) && script.lazy) {
-              continue;
-            }
-            const content = getDependencyEntryContent(script);
-            const src = getDependencyEntrySrc(script);
-            const attributes = getDependencyEntryAttributes(script);
-            if (content) {
-              const depKey2 = `script:content:${content}:${JSON.stringify(attributes ?? {})}`;
-              if (scriptDependencyKeys.has(depKey2)) {
-                continue;
-              }
-              scriptDependencyKeys.add(depKey2);
-              dependencies.push(
-                AssetFactory.createInlineContentScript({
-                  position: "head",
-                  content,
-                  bundle: false,
-                  attributes
-                })
-              );
-              continue;
-            }
-            if (!src) {
-              throw new Error(DEPENDENCY_ERRORS.INVALID_SCRIPT_ENTRY);
-            }
-            const resolvedPath = resolveDependencyPath(dir, src);
-            const depKey = `script:file:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
-            if (scriptDependencyKeys.has(depKey)) {
-              continue;
-            }
-            scriptDependencyKeys.add(depKey);
-            dependencies.push(
-              AssetFactory.createFileScript({
-                filepath: resolvedPath,
-                position: "head",
-                attributes: {
-                  type: "module",
-                  defer: "",
-                  ...attributes
-                }
-              })
-            );
-          }
-        }
-        const normalizedModules = normalizeModuleDeclarations(dependenciesConfig?.modules);
-        for (const declaration of normalizedModules) {
-          const existing = modulesMap.get(declaration.from);
-          if (!declaration.imports || declaration.imports.length === 0) {
-            modulesMap.set(declaration.from, null);
-            continue;
-          }
-          if (existing === null) {
-            continue;
-          }
-          const merged = existing ?? /* @__PURE__ */ new Set();
-          for (const imported of declaration.imports) {
-            merged.add(imported);
-          }
-          modulesMap.set(declaration.from, merged);
-        }
-        for (const [index, scriptEntry] of (dependenciesConfig?.scripts ?? []).entries()) {
-          if (!isDependencyEntryObject(scriptEntry) || !scriptEntry.lazy) {
-            continue;
-          }
-          const lazy = scriptEntry.lazy;
-          const content = scriptEntry.content;
-          const src = scriptEntry.src;
-          const attributes = scriptEntry.attributes;
-          if (content) {
-            const lazyKey2 = `lazy:${rapidhash(`${file}:entry:${index}:${content}`).toString(16)}`;
-            const depKey2 = `lazy:entry:content:${getLazyTriggerKey(lazy)}:${content}:${JSON.stringify(attributes ?? {})}`;
-            if (!lazyDependencyKeys.has(depKey2)) {
-              lazyDependencyKeys.add(depKey2);
-              dependencies.push(
-                AssetFactory.createContentScript({
-                  position: "head",
-                  content,
-                  excludeFromHtml: true,
-                  attributes: {
-                    type: "module",
-                    defer: "",
-                    "data-eco-lazy-key": lazyKey2,
-                    ...attributes
-                  }
-                })
-              );
-            }
-            registerLazyScript({
-              lazy,
-              lazyKey: lazyKey2
-            });
-            continue;
-          }
-          const script = src ?? getDependencyEntrySrcOrThrow(scriptEntry, DEPENDENCY_ERRORS.LAZY_SCRIPT_MISSING_SRC);
-          const resolvedPath = this.resolveDependencyPath(dir, script);
-          const fallbackUrl = this.resolveLazyScripts(dir, [script]).split(",")[0] ?? "";
-          const lazyKey = `lazy:${rapidhash(`${resolvedPath}:${getLazyTriggerKey(lazy)}`).toString(16)}`;
-          const depKey = `lazy:entry:file:${getLazyTriggerKey(lazy)}:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
-          if (!lazyDependencyKeys.has(depKey)) {
-            lazyDependencyKeys.add(depKey);
-            dependencies.push(
-              AssetFactory.createFileScript({
-                filepath: resolvedPath,
-                position: "head",
-                excludeFromHtml: true,
-                attributes: {
-                  type: "module",
-                  defer: "",
-                  "data-eco-lazy-key": lazyKey,
-                  ...attributes
-                }
-              })
-            );
-          }
-          registerLazyScript({
-            lazy,
-            lazyKey,
-            fallbackUrl
-          });
-        }
-        if (dependenciesConfig?.components) {
-          for (const nestedComponent of dependenciesConfig.components) {
-            if (nestedComponent?.config) {
-              collect(nestedComponent.config);
-            }
-          }
-        }
-        const autoVirtualImports = extractEcopagesVirtualImports(file);
-        for (const { from, imports } of autoVirtualImports) {
-          const existing = modulesMap.get(from);
-          if (!imports || imports.length === 0) {
-            if (existing !== null) modulesMap.set(from, null);
-            continue;
-          }
-          if (existing === null) continue;
-          const merged = existing ?? /* @__PURE__ */ new Set();
-          for (const imported of imports) merged.add(imported);
-          modulesMap.set(from, merged);
-        }
-      };
-      collect(component.config);
-      dependencies.push(
-        ...Array.from(modulesMap.entries()).map(([from, importsSet]) => {
-          const imports = importsSet ? Array.from(importsSet) : void 0;
-          return AssetFactory.createContentScript({
-            position: "head",
-            name: createModuleScriptName(from, imports),
-            content: imports && imports.length > 0 ? createNamedImportModuleSource(from, imports) : createNamespaceImportModuleSource(from),
-            attributes: {
-              type: "module",
-              defer: ""
-            }
-          });
-        })
-      );
-    }
-    const hasLazyDependencies = dependencies.some((dep) => dep.kind === "script" && dep.excludeFromHtml === true);
-    const processedDependencies = await this.assetProcessingService.processDependencies(
-      dependencies,
-      integrationName
-    );
-    const lazyKeyToOutputUrl = /* @__PURE__ */ new Map();
-    for (const dependency of processedDependencies) {
-      if (dependency.kind === "script" && dependency.srcUrl) {
-        const lazyKey = dependency.attributes?.["data-eco-lazy-key"];
-        if (lazyKey) {
-          lazyKeyToOutputUrl.set(lazyKey, dependency.srcUrl);
-        }
-      }
-    }
-    for (const [config, lazyGroupsMap] of lazyScriptsByConfig.entries()) {
-      const rawGroups = [];
-      for (const group of lazyGroupsMap.values()) {
-        const resolvedUrls = group.scripts.map(({ lazyKey, fallbackUrl }) => lazyKeyToOutputUrl.get(lazyKey) ?? fallbackUrl).filter((url) => Boolean(url && url.length > 0));
-        if (resolvedUrls.length === 0) {
-          continue;
-        }
-        rawGroups.push({ lazy: group.lazy, scripts: Array.from(new Set(resolvedUrls)) });
-      }
-      if (hasLazyDependencies) {
-        config._resolvedLazyTriggers = buildResolvedLazyTriggers(config, rawGroups);
-        config._resolvedLazyScripts = void 0;
-      }
-    }
-    return processedDependencies;
-  }
-}
-export {
-  DEPENDENCY_ERRORS,
-  DependencyResolverService
-};

package/src/route-renderer/page-loading/page-module-loader.d.ts

@@ -1,90 +0,0 @@
-import type { EcoPageFile, GetMetadata, GetMetadataContext, GetStaticProps, PageMetadataProps, RouteRendererOptions, EcoPageComponent } from '../../types/public-types.js';
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-/**
- * Loads route page modules and normalizes their data hooks for rendering.
- *
- * @remarks
- * This service keeps the render pipeline from depending directly on raw module
- * imports. It owns the shared server-module transpiler setup, the precedence
- * rules between component statics and module exports, and the normalization of
- * page props and metadata into one renderer-facing shape.
- */
-export declare class PageModuleLoaderService {
-    private appModuleLoader;
-    private appConfig;
-    private runtimeOrigin;
-    /**
-     * Creates the page-module loader for one app/runtime instance.
-     *
-     * @param appConfig Finalized app config that owns build and invalidation state.
-     * @param runtimeOrigin Runtime origin exposed to page data hooks.
-     */
-    constructor(appConfig: EcoPagesAppConfig, runtimeOrigin: string);
-    /**
-     * Imports one page module through the shared server-side module loading path.
-     *
-     * @remarks
-     * The underlying transpiler keeps Bun and Node aligned on one framework-owned
-     * loading contract even though the runtime-specific execution transport differs.
-     */
-    importPageFile(file: string, options?: {
-        bypassCache?: boolean;
-        cacheScope?: string;
-    }): Promise<EcoPageFile>;
-    /**
-     * Executes the page's static-props hook with Ecopages runtime context.
-     *
-     * @remarks
-     * Pages without a static-props hook still return a normalized empty props
-     * object so downstream render preparation does not branch on hook presence.
-     */
-    getStaticPropsForPage(options: {
-        getStaticProps?: GetStaticProps<Record<string, unknown>>;
-        params?: RouteRendererOptions['params'];
-    }): Promise<{
-        props: Record<string, unknown>;
-        metadata?: PageMetadataProps;
-    }>;
-    /**
-     * Builds the final page metadata object for one render request.
-     *
-     * @remarks
-     * App-level default metadata forms the baseline, then page-level metadata is
-     * overlaid so route-specific fields win without dropping global defaults.
-     */
-    getMetadataPropsForPage(options: {
-        getMetadata: GetMetadata | undefined;
-        context: GetMetadataContext;
-    }): Promise<PageMetadataProps>;
-    /**
-     * Loads a page module and normalizes integration-facing exports.
-     * When both component static methods and module exports exist, component statics win.
-     */
-    resolvePageModule(options: {
-        file: string;
-        importPageFileFn?: (file: string) => Promise<EcoPageFile>;
-    }): Promise<{
-        Page: EcoPageFile['default'] | EcoPageComponent<any>;
-        getStaticProps?: GetStaticProps<Record<string, unknown>>;
-        getMetadata?: GetMetadata;
-        integrationSpecificProps: Record<string, unknown>;
-    }>;
-    /**
-     * Resolves the page data needed by the render pipeline.
-     *
-     * @remarks
-     * Static props are resolved first because page metadata may depend on those
-     * props. This preserves the same ordering whether data hooks are declared as
-     * component statics or module exports.
-     */
-    resolvePageData(options: {
-        pageModule: {
-            getStaticProps?: GetStaticProps<Record<string, unknown>>;
-            getMetadata?: GetMetadata;
-        };
-        routeOptions: RouteRendererOptions;
-    }): Promise<{
-        props: Record<string, unknown>;
-        metadata: PageMetadataProps;
-    }>;
-}

package/src/route-renderer/page-loading/page-module-loader.js

@@ -1,127 +0,0 @@
-import { invariant } from "../../utils/invariant.js";
-import { getAppModuleLoader } from "../../services/module-loading/app-server-module-transpiler.service.js";
-import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
-class PageModuleLoaderService {
-  appModuleLoader;
-  appConfig;
-  runtimeOrigin;
-  /**
-   * Creates the page-module loader for one app/runtime instance.
-   *
-   * @param appConfig Finalized app config that owns build and invalidation state.
-   * @param runtimeOrigin Runtime origin exposed to page data hooks.
-   */
-  constructor(appConfig, runtimeOrigin) {
-    this.appConfig = appConfig;
-    this.runtimeOrigin = runtimeOrigin;
-    this.appModuleLoader = getAppModuleLoader(appConfig);
-  }
-  /**
-   * Imports one page module through the shared server-side module loading path.
-   *
-   * @remarks
-   * The underlying transpiler keeps Bun and Node aligned on one framework-owned
-   * loading contract even though the runtime-specific execution transport differs.
-   */
-  async importPageFile(file, options) {
-    try {
-      return await this.appModuleLoader.importModule({
-        filePath: file,
-        rootDir: this.appConfig.rootDir,
-        outdir: `${resolveInternalExecutionDir(this.appConfig)}/.server-modules`,
-        bypassCache: options?.bypassCache,
-        cacheScope: options?.cacheScope,
-        transpileErrorMessage: (details) => `Error transpiling page file: ${details}`,
-        noOutputMessage: (targetFilePath) => `No transpiled output generated for page: ${targetFilePath}`
-      });
-    } catch (error) {
-      invariant(false, `Error importing page file: ${error}`);
-    }
-  }
-  /**
-   * Executes the page's static-props hook with Ecopages runtime context.
-   *
-   * @remarks
-   * Pages without a static-props hook still return a normalized empty props
-   * object so downstream render preparation does not branch on hook presence.
-   */
-  async getStaticPropsForPage(options) {
-    const { getStaticProps, params } = options;
-    return getStaticProps ? await getStaticProps({
-      pathname: { params: params ?? {} },
-      appConfig: this.appConfig,
-      runtimeOrigin: this.runtimeOrigin
-    }).then((data) => data).catch((err) => {
-      throw new Error(`Error fetching static props: ${err.message}`);
-    }) : {
-      props: {},
-      metadata: void 0
-    };
-  }
-  /**
-   * Builds the final page metadata object for one render request.
-   *
-   * @remarks
-   * App-level default metadata forms the baseline, then page-level metadata is
-   * overlaid so route-specific fields win without dropping global defaults.
-   */
-  async getMetadataPropsForPage(options) {
-    const { getMetadata, context } = options;
-    let metadata = this.appConfig.defaultMetadata;
-    if (getMetadata) {
-      const dynamicMetadata = await getMetadata({
-        params: context.params,
-        query: context.query,
-        props: context.props,
-        appConfig: this.appConfig
-      });
-      metadata = { ...metadata, ...dynamicMetadata };
-    }
-    return metadata;
-  }
-  /**
-   * Loads a page module and normalizes integration-facing exports.
-   * When both component static methods and module exports exist, component statics win.
-   */
-  async resolvePageModule(options) {
-    const module = await (options.importPageFileFn ?? ((file) => this.importPageFile(file)))(options.file);
-    const {
-      default: Page,
-      getStaticProps: moduleGetStaticProps,
-      getMetadata: moduleGetMetadata,
-      ...integrationSpecificProps
-    } = module;
-    return {
-      Page,
-      getStaticProps: Page.staticProps ?? moduleGetStaticProps,
-      getMetadata: Page.metadata ?? moduleGetMetadata,
-      integrationSpecificProps
-    };
-  }
-  /**
-   * Resolves the page data needed by the render pipeline.
-   *
-   * @remarks
-   * Static props are resolved first because page metadata may depend on those
-   * props. This preserves the same ordering whether data hooks are declared as
-   * component statics or module exports.
-   */
-  async resolvePageData(options) {
-    const { props } = await this.getStaticPropsForPage({
-      getStaticProps: options.pageModule.getStaticProps,
-      params: options.routeOptions.params
-    });
-    const metadata = await this.getMetadataPropsForPage({
-      getMetadata: options.pageModule.getMetadata,
-      context: {
-        props,
-        params: options.routeOptions.params ?? {},
-        query: options.routeOptions.query ?? {}
-      }
-    });
-    return { props, metadata };
-  }
-}
-export {
-  PageModuleLoaderService
-};