@ecopages/core 0.2.0-alpha.7 → 0.2.0-alpha.8

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

@@ -0,0 +1,442 @@
+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") {
+        const importedName = spec.imported?.type === "Identifier" ? spec.imported.name : spec.imported?.type === "Literal" ? spec.imported.value : spec.local?.name;
+        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 = imports.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.createContentScript({
+                  position: "head",
+                  content,
+                  attributes: {
+                    type: "module",
+                    defer: "",
+                    ...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

@@ -0,0 +1,87 @@
+import type { EcoPageFile, GetMetadata, GetMetadataContext, GetStaticProps, PageMetadataProps, RouteRendererOptions, EcoPageComponent } from '../../public-types.js';
+import type { EcoPagesAppConfig } from '../../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 serverModuleTranspiler;
+    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): 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

@@ -0,0 +1,124 @@
+import { invariant } from "../../utils/invariant.js";
+import { getAppServerModuleTranspiler } from "../../services/module-loading/app-server-module-transpiler.service.js";
+import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
+class PageModuleLoaderService {
+  serverModuleTranspiler;
+  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.serverModuleTranspiler = getAppServerModuleTranspiler(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) {
+    try {
+      return await this.serverModuleTranspiler.importModule({
+        filePath: file,
+        outdir: `${resolveInternalExecutionDir(this.appConfig)}/.server-modules`,
+        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
+};