@monkeyplus/flow 6.0.56 → 6.0.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "6.0.56",
+  "version": "6.0.58",
   "description": "@monkeyplus/flow package-first runtime with Vite, Nitro, Vue and a workspace playground.",
   "license": "MIT",
   "publishConfig": {

package/server/lib/pages.d.ts

@@ -1,4 +1,4 @@
-import type { DynamicRouteEntry, FlowLocale, GetUrlOptions, HeadDefinition, PageDefinition, PageLocaleDefinition, PageUrlInfo } from '../../src/runtime/pages';
+import type { DynamicRouteEntry, FlowLocale, GetUrlOptions, HeadDefinition, PageDefinition, PageLocaleDefinition, PageUrlInfo, BreadcrumbItem } from '../../src/runtime/pages';
 export interface ResolvedPage {
     definition: PageDefinition;
     locale: FlowLocale;
@@ -13,8 +13,10 @@ export interface ResolvedPage {
      */
     seo: HeadDefinition;
     context: Record<string, unknown>;
+    breadcrumbs: BreadcrumbItem[];
 }
 export declare function getUrl(namePage: string, localeCode?: string, options?: GetUrlOptions): Promise<string | undefined>;
 export declare function getUrls(withLocale?: boolean, omitNoPublish?: boolean): Promise<(string | PageUrlInfo)[]>;
 export declare function resolvePage(pathname: string, request?: Request): Promise<ResolvedPage | undefined>;
 export declare function resolvePageByName(name: string, pathname: string, request?: Request): Promise<ResolvedPage | undefined>;
+export declare function resolveBreadcrumbs(pageName: string, pathname: string, localeCode: string, params: Record<string, string>, dynamic: DynamicRouteEntry | undefined, request: Request | undefined, visited?: Set<string>): Promise<BreadcrumbItem[]>;

package/server/lib/pages.mjs

@@ -98,10 +98,14 @@ function createLocale(code) {
 function createContext(definition, locale, localePage, pathname, params, dynamic, request) {
   const imageUtils = getFlowImageRuntimeUtils();
   const preview = request?.headers.get("cookie")?.includes("flow_preview=true") || false;
+  const config = getFlowRuntimeConfig();
+  const siteUrl = config.flow?.siteUrl || "";
+  const fullPath = siteUrl ? `${siteUrl.replace(/\/$/, "")}${pathname}` : pathname;
   return {
     dynamic,
     locale,
     path: pathname,
+    fullPath,
     name: definition.name,
     page: localePage,
     params,
@@ -317,6 +321,7 @@ export async function resolvePage(pathname, request) {
     const assign = match.localePage.dynamic?.assign;
     const resolvedContext = mergeResolvedContext(context, layoutContext.context, dynamic, assign);
     const head = mergeHeadDefinitions(layoutContext.head.global, layoutContext.head.layout, pageHead);
+    const breadcrumbs = await resolveBreadcrumbs(match.definition.name, pathname, match.localeCode, match.params, dynamic, request);
     return {
       definition: match.definition,
       locale,
@@ -327,7 +332,8 @@ export async function resolvePage(pathname, request) {
       dynamic,
       head,
       seo: head,
-      context: resolvedContext
+      context: resolvedContext,
+      breadcrumbs
     };
   }
   return void 0;
@@ -350,6 +356,7 @@ export async function resolvePageByName(name, pathname, request) {
     const layoutContext = await resolveLayoutContext(definition, ctx);
     const context = localePage.context ? await localePage.context(ctx) : {};
     const head = mergeHeadDefinitions(layoutContext.head.global, layoutContext.head.layout, pageHead);
+    const breadcrumbs = await resolveBreadcrumbs(definition.name, pathname, localeCode, params, void 0, request);
     return {
       definition,
       locale,
@@ -359,8 +366,56 @@ export async function resolvePageByName(name, pathname, request) {
       params,
       head,
       seo: head,
-      context: mergeResolvedContext(context, layoutContext.context)
+      context: mergeResolvedContext(context, layoutContext.context),
+      breadcrumbs
     };
   }
   return void 0;
 }
+export async function resolveBreadcrumbs(pageName, pathname, localeCode, params, dynamic, request, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(pageName)) {
+    return [];
+  }
+  visited.add(pageName);
+  const definition = pageDefinitions.find((candidate) => candidate.name === pageName);
+  if (!definition) return [];
+  const localePage = definition.locales[localeCode];
+  if (!localePage || !localePage.breadcrumb) return [];
+  const locale = createLocale(localeCode);
+  const ctx = createContext(definition, locale, localePage, pathname, params, dynamic, request);
+  const pageContext = await executeContextDefinition(localePage.context, pageName, ctx);
+  const pageHead = await executeContextDefinition(localePage.head, pageName, ctx);
+  const breadcrumbCtx = {
+    ...ctx,
+    context: pageContext,
+    head: pageHead,
+    seo: pageHead.seo || pageHead
+  };
+  const result = await localePage.breadcrumb(breadcrumbCtx);
+  if (!result) return [];
+  let currentItems = [];
+  if (result.items) {
+    currentItems = result.items;
+  } else if (result.item) {
+    currentItems = [result.item];
+  }
+  for (const item of currentItems) {
+    if (!item.url || item.url === "#") {
+      item.url = await ctx.utils.getUrl(pageName, localeCode, { params });
+    }
+  }
+  let parentItems = [];
+  if (result.parent) {
+    let parentName = "";
+    let parentParams = params;
+    if (typeof result.parent === "string") {
+      parentName = result.parent;
+    } else {
+      parentName = result.parent.name;
+      parentParams = result.parent.params;
+    }
+    const parentPathname = await ctx.utils.getUrl(parentName, localeCode, { params: parentParams }) || "/";
+    parentItems = await resolveBreadcrumbs(parentName, parentPathname, localeCode, parentParams, void 0, request, visited);
+  }
+  return [...parentItems, ...currentItems];
+}

package/server/lib/render.mjs

@@ -142,6 +142,7 @@ ${cleanTrace}`);
   };
   app.provide("context", context);
   app.provide("utils", utils);
+  app.provide("breadcrumbs", page.breadcrumbs);
   const head = createHead();
   head.use(UnheadSchemaOrg());
   head.push({
@@ -149,6 +150,9 @@ ${cleanTrace}`);
       lang: page.locale.lang
     }
   });
+  if (page.head) {
+    head.push(page.head);
+  }
   head.push(normalizeSeoToHead(page.head, fallbackTitle, fallbackDescription));
   app.use(head);
   installFlowVuePlugins(app);
@@ -168,7 +172,8 @@ export async function renderDocument(page, clientAssets) {
     title: fallbackTitle,
     locale: page.locale,
     mode,
-    images: getFlowImageBootPayload()
+    images: getFlowImageBootPayload(),
+    breadcrumbs: page.breadcrumbs
   };
   const rendered = await renderBody(page);
   const body = stripVueFragmentMarkers(rendered.body);
@@ -198,5 +203,28 @@ export async function renderDocument(page, clientAssets) {
     ].join("\n    "),
     body: pageMarkup
   });
-  return transformHtmlTemplate(rendered.head, html);
+  let finalHtml = await transformHtmlTemplate(rendered.head, html);
+  const schemaOrgConfig = page.head.templateParams?.schemaOrg;
+  if (schemaOrgConfig?.inLanguage && schemaOrgConfig.inLanguage !== page.locale.lang) {
+    finalHtml = finalHtml.replace(/<script[^>]*data-hid="schema-org-graph"[^>]*>([\s\S]*?)<\/script>/, (match, content) => {
+      try {
+        const data = JSON.parse(content);
+        const replaceLang = (obj) => {
+          if (Array.isArray(obj)) {
+            obj.forEach(replaceLang);
+          } else if (typeof obj === "object" && obj !== null) {
+            if (obj.inLanguage === page.locale.lang) {
+              obj.inLanguage = schemaOrgConfig.inLanguage;
+            }
+            Object.values(obj).forEach(replaceLang);
+          }
+        };
+        replaceLang(data);
+        return match.replace(content, JSON.stringify(data));
+      } catch (e) {
+        return match;
+      }
+    });
+  }
+  return finalHtml;
 }

package/src/public/index.d.ts

@@ -1,6 +1,6 @@
 export type { ContentDirectoryNode, ContentEntry, ContentFileNode, ContentTreeNode, } from '../../modules/content/query.ts';
 export type { FlowBootPayload } from '../runtime/boot.ts';
-export { useContext, useGlobal, useHead, useLocale, usePage, useSeo, useSharedContext, useUtils, useView, } from '../runtime/composables.ts';
+export { useContext, useGlobal, useHead, useLocale, usePage, useSeo, useSharedContext, useUrl, useUtils, useView, useBreadcrumb, } from '../runtime/composables.ts';
 export { defineFlowConfig, defineFlowModule, resolveFlowConfig } from '../runtime/config.ts';
 export type { FlowConfig, UserFlowConfig, } from '../runtime/config.ts';
 export { useSchemaOrg } from '../runtime/head.ts';

package/src/public/index.mjs

@@ -6,8 +6,10 @@ export {
   usePage,
   useSeo,
   useSharedContext,
+  useUrl,
   useUtils,
-  useView
+  useView,
+  useBreadcrumb
 } from "../runtime/composables.mjs";
 export { defineFlowConfig, defineFlowModule, resolveFlowConfig } from "../runtime/config.mjs";
 export { useSchemaOrg } from "../runtime/head.mjs";

package/src/public/vite.mjs

@@ -343,6 +343,9 @@ export function createFlowViteConfig(options = {}) {
   const { imports: userImports, ...userAutoImport } = options.userFlowConfig?.autoImport || {};
   const uiOptions = options.userFlowConfig?.ui || {};
   return defineConfig({
+    define: {
+      "import.meta.env.FLOW_SITE_URL": JSON.stringify(flowConfig.siteUrl || "")
+    },
     plugins: [
       createFlowVirtualServerModules(projectRoot, flowConfig),
       createFlowVirtualClientPages(projectRoot),
@@ -382,9 +385,11 @@ export function createFlowViteConfig(options = {}) {
                 "useUtils",
                 "useSharedContext",
                 "useGlobal",
+                "useUrl",
                 "useLocale",
                 "usePage",
-                "useView"
+                "useView",
+                "useBreadcrumb"
               ],
               ...mappedNitroImports
             },

package/src/runtime/boot.d.ts

@@ -1,17 +0,0 @@
-import type { FlowImageMeta, FlowImageOptions } from '../../modules/images/runtime/types.ts';
-import type { FlowHydrationMode, FlowLocale } from './pages';
-export interface FlowImageBootPayload {
-    all: Record<string, FlowImageMeta>;
-    options: FlowImageOptions;
-    generateOutput: boolean;
-    strapiURL?: string;
-}
-export interface FlowBootPayload {
-    path: string;
-    bundle: string;
-    template: string;
-    title: string;
-    locale: FlowLocale;
-    mode: FlowHydrationMode;
-    images?: FlowImageBootPayload;
-}

package/src/runtime/composables.d.ts

@@ -1,4 +1,4 @@
-import type { FlowLocale, PageContextUtils, PageDefinition } from './pages.ts';
+import type { BreadcrumbItem, FlowLocale, PageContextUtils, PageDefinition } from './pages.ts';
 export declare function useContext<T = any>(): T;
 export declare function useSeo(): any;
 export declare function useHead<T = any>(): T;
@@ -8,3 +8,11 @@ export declare function useGlobal<T = any>(): T;
 export declare function useLocale(): FlowLocale;
 export declare function usePage(): PageDefinition;
 export declare function useView(): PageDefinition['view'];
+export interface UrlInfo {
+    pathname: string;
+    siteUrl?: string;
+    href: string;
+    joinUrl: (...params: string[]) => string;
+}
+export declare function useUrl(): UrlInfo;
+export declare function useBreadcrumb(): BreadcrumbItem[];

package/src/runtime/composables.mjs

@@ -1,3 +1,4 @@
+import { joinURL } from "ufo";
 import { inject } from "vue";
 export function useContext() {
   const ctx = inject("context", {});
@@ -37,3 +38,24 @@ export function useView() {
   const ctx = inject("context", {});
   return { ...ctx.page?.view || {} };
 }
+export function useUrl() {
+  const ctx = inject("context", {});
+  const pathname = ctx.path || "/";
+  const siteUrl = import.meta.env.FLOW_SITE_URL || void 0;
+  let href = pathname || "/";
+  if (siteUrl) {
+    const base = siteUrl.endsWith("/") ? siteUrl.slice(0, -1) : siteUrl;
+    const path = href.startsWith("/") ? href : `/${href}`;
+    href = base + path;
+  }
+  return {
+    pathname,
+    siteUrl,
+    href,
+    joinUrl: (...params) => joinURL(siteUrl || "", ...params)
+  };
+}
+export function useBreadcrumb() {
+  const breadcrumbs = inject("breadcrumbs", []);
+  return breadcrumbs;
+}

package/src/runtime/islands.mjs

@@ -61,6 +61,7 @@ async function hydrateIsland(element, boot) {
   const imageUtils = createBootImageUtils(boot);
   app.use(getClientHead());
   app.provide("utils", imageUtils);
+  app.provide("breadcrumbs", boot?.breadcrumbs || []);
   installFlowVuePlugins(app);
   app.mount(element);
   element.dataset.flowIslandHydrated = "true";

package/src/runtime/pages.d.ts

@@ -99,6 +99,7 @@ export interface PageContextUtils {
 export interface PageContextInput {
     locale: FlowLocale;
     path: string;
+    fullPath?: string;
     name: string;
     view: PageViewDefinition;
     page: PageLocaleDefinition;
@@ -107,6 +108,27 @@ export interface PageContextInput {
     utils: PageContextUtils;
     preview?: boolean;
 }
+export interface BreadcrumbItem {
+    title: string;
+    caption?: string;
+    url?: string;
+}
+export interface BreadcrumbDefinition {
+    parent?: string | {
+        name: string;
+        params: Record<string, string>;
+    };
+    item?: BreadcrumbItem;
+    items?: BreadcrumbItem[];
+}
+export interface BreadcrumbContextInput extends PageContextInput {
+    context: Record<string, unknown>;
+    head: HeadDefinition;
+    /**
+     * @deprecated Use head.
+     */
+    seo: HeadDefinition;
+}
 export interface PageLocaleDefinition {
     url: string;
     head?: (ctx: PageContextInput) => MaybePromise<HeadDefinition>;
@@ -115,6 +137,7 @@ export interface PageLocaleDefinition {
      */
     seo?: (ctx: PageContextInput) => MaybePromise<HeadDefinition>;
     context?: (ctx: PageContextInput) => MaybePromise<Record<string, unknown>>;
+    breadcrumb?: (ctx: BreadcrumbContextInput) => MaybePromise<BreadcrumbDefinition>;
     dynamic?: DynamicRouteOptions;
 }
 export interface PageDefinition {

package/src/runtime/virtual.d.ts

@@ -123,4 +123,4 @@ declare module 'virtual:flow/bases' {
   const bases: Record<string, string>;
 
   export default bases;
-}
+}