@monkeyplus/flow 5.0.0-rc.99 → 6.0.1

package/server/lib/pages.mjs

@@ -0,0 +1,276 @@
+import { useRuntimeConfig } from "nitro/runtime-config";
+import pageDefinitions from "virtual:flow/pages";
+const dynamicRouteCache = /* @__PURE__ */ new Map();
+function normalizePath(value) {
+  if (!value || value === "/") {
+    return "/";
+  }
+  return value.length > 1 && value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function scorePattern(pattern) {
+  return normalizePath(pattern).split("/").filter(Boolean).reduce((score, segment) => {
+    if (segment === "**") {
+      return score;
+    }
+    if (segment.startsWith(":")) {
+      return score + 1;
+    }
+    return score + 3;
+  }, pattern.includes("**") ? 0 : 2);
+}
+function matchPattern(pattern, pathname) {
+  const expected = normalizePath(pattern).split("/").filter(Boolean);
+  const received = normalizePath(pathname).split("/").filter(Boolean);
+  const params = {};
+  let index = 0;
+  let offset = 0;
+  while (index < expected.length) {
+    const segment = expected[index];
+    const current = received[offset];
+    if (segment === "**") {
+      params._ = received.slice(offset).join("/");
+      return params;
+    }
+    if (!current) {
+      return null;
+    }
+    if (segment.startsWith(":")) {
+      params[segment.slice(1)] = current;
+      index += 1;
+      offset += 1;
+      continue;
+    }
+    if (segment !== current) {
+      return null;
+    }
+    index += 1;
+    offset += 1;
+  }
+  return offset === received.length ? params : null;
+}
+function createLocale(code) {
+  const config = useRuntimeConfig();
+  const defaults = config.flow?.locale;
+  const [lang = defaults?.language || "es", loc = defaults?.location || "ec"] = code.split("-");
+  return {
+    code,
+    lang,
+    loc
+  };
+}
+function createContext(definition, locale, localePage, pathname, params, dynamic) {
+  return {
+    dynamic,
+    locale,
+    path: pathname,
+    name: definition.name,
+    page: localePage,
+    params,
+    view: definition.view,
+    utils: {
+      getLocale() {
+        return locale;
+      },
+      async getUrl(namePage, localeCode, options) {
+        return await getUrl(namePage, localeCode, options);
+      },
+      async getUrls(withLocale, omitNoPublish) {
+        return await getUrls(withLocale, omitNoPublish);
+      }
+    }
+  };
+}
+function isDynamicPattern(pattern) {
+  return pattern.includes("/:") || pattern.includes("/**");
+}
+function replacePath(pattern, url) {
+  let resolved = pattern;
+  if (typeof url === "string") {
+    return normalizePath(resolved.replace("/**", `/${url}`));
+  }
+  for (const [key, value] of Object.entries(url)) {
+    if (key === "_") {
+      continue;
+    }
+    resolved = resolved.replace(`:${key}`, value);
+  }
+  if (url._ && resolved.endsWith("/**")) {
+    resolved = resolved.replace("/**", `/${url._}`);
+  }
+  return normalizePath(resolved.replaceAll("**", ""));
+}
+function toPublicRoutePattern(url) {
+  return normalizePath(url.replaceAll("*", ""));
+}
+function combineName(name, dynamicName) {
+  return `${name.replace(/\/*$/, "")}/${dynamicName.replace(/^\/*/, "")}`;
+}
+function getEnabledLocaleCodes() {
+  const runtimeConfig = useRuntimeConfig();
+  return runtimeConfig.flow?.locale?.locales || [];
+}
+async function getDynamicEntries(definition, localeCode, ctx) {
+  const dynamic = ctx.page.dynamic;
+  if (!dynamic) {
+    return [];
+  }
+  const cacheKey = `${definition.name}:${localeCode}:${ctx.page.url}`;
+  if (dynamic.options?.once) {
+    const cached = dynamicRouteCache.get(cacheKey);
+    if (cached) {
+      return await cached;
+    }
+    const pending = Promise.resolve(dynamic.method(ctx));
+    dynamicRouteCache.set(cacheKey, pending);
+    return await pending;
+  }
+  return await dynamic.method(ctx);
+}
+async function resolveDynamicEntry(definition, localeCode, localePage, ctx, pathname) {
+  if (!localePage.dynamic || !isDynamicPattern(localePage.url)) {
+    return void 0;
+  }
+  const entries = await getDynamicEntries(definition, localeCode, ctx);
+  const resolvedPath = normalizePath(pathname);
+  return entries.find((entry) => replacePath(localePage.url, entry.url) === resolvedPath);
+}
+export async function getUrl(namePage, localeCode, options = {}) {
+  const enabledLocales = getEnabledLocaleCodes();
+  const targetLocale = localeCode || enabledLocales[0];
+  for (const definition of pageDefinitions) {
+    if (definition.name !== namePage) {
+      continue;
+    }
+    const localeEntries = targetLocale ? [targetLocale] : Object.keys(definition.locales);
+    for (const code of localeEntries) {
+      const localePage = definition.locales[code];
+      if (!localePage) {
+        continue;
+      }
+      if (options.url) {
+        return replacePath(localePage.url, options.url);
+      }
+      if (options.params) {
+        return replacePath(localePage.url, options.params);
+      }
+      if (localePage.dynamic && options.dynamicName) {
+        const locale = createLocale(code);
+        const ctx = createContext(definition, locale, localePage, localePage.url, {});
+        const entries = await getDynamicEntries(definition, code, ctx);
+        const entry = entries.find((candidate) => candidate.name === options.dynamicName);
+        if (!entry) {
+          return void 0;
+        }
+        return replacePath(localePage.url, entry.url);
+      }
+      return toPublicRoutePattern(localePage.url);
+    }
+  }
+  return void 0;
+}
+export async function getUrls(withLocale = false, omitNoPublish = false) {
+  const enabledLocales = getEnabledLocaleCodes();
+  const urls = [];
+  for (const definition of pageDefinitions) {
+    if (omitNoPublish && definition.noPublish) {
+      continue;
+    }
+    for (const [localeCode, localePage] of Object.entries(definition.locales)) {
+      if (enabledLocales.length && !enabledLocales.includes(localeCode)) {
+        continue;
+      }
+      if (localePage.dynamic) {
+        const locale = createLocale(localeCode);
+        const ctx = createContext(definition, locale, localePage, localePage.url, {});
+        const entries = await getDynamicEntries(definition, localeCode, ctx);
+        for (const entry of entries) {
+          const url2 = replacePath(localePage.url, entry.url);
+          urls.push(withLocale ? { url: url2, locale: localeCode, name: combineName(definition.name, entry.name) } : url2);
+        }
+        continue;
+      }
+      const url = toPublicRoutePattern(localePage.url);
+      urls.push(withLocale ? { url, locale: localeCode, name: definition.name } : url);
+    }
+  }
+  return urls;
+}
+export async function resolvePage(pathname) {
+  const runtimeConfig = useRuntimeConfig();
+  const enabledLocales = runtimeConfig.flow?.locale?.locales || [];
+  const candidates = [];
+  for (const definition of pageDefinitions) {
+    for (const [localeCode, localePage] of Object.entries(definition.locales)) {
+      if (enabledLocales.length && !enabledLocales.includes(localeCode)) {
+        continue;
+      }
+      const params = matchPattern(localePage.url, pathname);
+      if (params) {
+        candidates.push({
+          definition,
+          localeCode,
+          localePage,
+          params,
+          score: scorePattern(localePage.url)
+        });
+      }
+    }
+  }
+  const sortedCandidates = candidates.sort((left, right) => right.score - left.score);
+  for (const match of sortedCandidates) {
+    const locale = createLocale(match.localeCode);
+    const baseCtx = createContext(match.definition, locale, match.localePage, pathname, match.params);
+    const dynamic = await resolveDynamicEntry(match.definition, match.localeCode, match.localePage, baseCtx, pathname);
+    if (match.localePage.dynamic && !dynamic) {
+      continue;
+    }
+    const ctx = createContext(match.definition, locale, match.localePage, pathname, match.params, dynamic);
+    const head = match.localePage.head ? await match.localePage.head(ctx) : match.localePage.seo ? await match.localePage.seo(ctx) : {};
+    const context = match.localePage.context ? await match.localePage.context(ctx) : {};
+    const assign = match.localePage.dynamic?.assign;
+    const resolvedContext = assign && dynamic?.context ? { ...context, [assign]: dynamic.context, dynamic } : dynamic ? { ...context, dynamic } : context;
+    return {
+      definition: match.definition,
+      locale,
+      localeCode: match.localeCode,
+      localePage: match.localePage,
+      pathname,
+      params: match.params,
+      dynamic,
+      head,
+      seo: head,
+      context: resolvedContext
+    };
+  }
+  return void 0;
+}
+export async function resolvePageByName(name, pathname) {
+  const runtimeConfig = useRuntimeConfig();
+  const enabledLocales = runtimeConfig.flow?.locale?.locales || [];
+  const definition = pageDefinitions.find((candidate) => candidate.name === name);
+  if (!definition) {
+    return void 0;
+  }
+  for (const [localeCode, localePage] of Object.entries(definition.locales)) {
+    if (enabledLocales.length && !enabledLocales.includes(localeCode)) {
+      continue;
+    }
+    const locale = createLocale(localeCode);
+    const params = {};
+    const ctx = createContext(definition, locale, localePage, pathname, params);
+    const head = localePage.head ? await localePage.head(ctx) : localePage.seo ? await localePage.seo(ctx) : {};
+    const context = localePage.context ? await localePage.context(ctx) : {};
+    return {
+      definition,
+      locale,
+      localeCode,
+      localePage,
+      pathname,
+      params,
+      head,
+      seo: head,
+      context
+    };
+  }
+  return void 0;
+}

package/server/lib/render.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedPage } from './pages';
+export interface FlowClientAssets {
+    entry: string;
+    css?: Array<Record<string, string>>;
+    js?: Array<Record<string, string>>;
+}
+export declare function renderDocument(page: ResolvedPage, clientAssets: FlowClientAssets): Promise<string>;

package/server/lib/render.mjs

@@ -0,0 +1,156 @@
+import UApp from "@nuxt/ui/components/App.vue";
+import { createHead } from "@unhead/vue/server";
+import { renderToString } from "@vue/server-renderer";
+import { transformHtmlTemplate } from "unhead/server";
+import bases from "virtual:flow/bases";
+import layouts from "virtual:flow/layouts";
+import templates from "virtual:flow/templates";
+import { createSSRApp, defineComponent, h } from "vue";
+import { installFlowVuePlugins } from "../../src/runtime/vue";
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function asString(value, fallback) {
+  return typeof value === "string" && value.length ? value : fallback;
+}
+function serializeBootPayload(payload) {
+  return JSON.stringify(payload).replaceAll("<", "\\u003c");
+}
+function serializeAttrs(attrs) {
+  return Object.entries(attrs).map(([key, value]) => `${key}="${escapeHtml(value)}"`).join(" ");
+}
+function renderClientHead(assets) {
+  const tags = [
+    ...(assets.css || []).map((attrs) => `<link ${serializeAttrs({ rel: "stylesheet", ...attrs })}>`),
+    ...(assets.js || []).map((attrs) => `<link ${serializeAttrs({ rel: "modulepreload", ...attrs })}>`),
+    `<script type="module" src="${escapeHtml(assets.entry)}"><\/script>`
+  ];
+  return tags.join("\n    ");
+}
+function applyBaseTemplate(template, payload) {
+  return template.replaceAll("{{lang}}", escapeHtml(payload.lang)).replaceAll("{{title}}", escapeHtml(payload.title)).replaceAll("{{description}}", escapeHtml(payload.description)).replaceAll("{{head}}", payload.head).replaceAll("{{body}}", payload.body);
+}
+function stripVueFragmentMarkers(value) {
+  let rendered = value.trim();
+  while (rendered.startsWith("<!--[-->") && rendered.endsWith("<!--]-->")) {
+    rendered = rendered.slice("<!--[-->".length, -"<!--]-->".length).trim();
+  }
+  return rendered;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function resolveString(value) {
+  return typeof value === "string" && value.length ? value : void 0;
+}
+function normalizeSeoToHead(head, fallbackTitle, fallbackDescription) {
+  const source = isRecord(head) ? { ...head } : {};
+  const meta = Array.isArray(source.meta) ? [...source.meta] : [];
+  const title = resolveString(source.title) || fallbackTitle;
+  const description = resolveString(source.description) || fallbackDescription;
+  const keywords = resolveString(source.keywords);
+  const imageSocial = resolveString(source.imageSocial);
+  const twitterSite = resolveString(source.twitterSite);
+  const google = source.google;
+  if (!meta.some((entry) => isRecord(entry) && entry.name === "description")) {
+    meta.push({ name: "description", content: description });
+  }
+  if (keywords && !meta.some((entry) => isRecord(entry) && entry.name === "keywords")) {
+    meta.push({ name: "keywords", content: keywords });
+  }
+  if (imageSocial) {
+    if (!meta.some((entry) => isRecord(entry) && entry.property === "og:image")) {
+      meta.push({ property: "og:image", content: imageSocial });
+    }
+    if (!meta.some((entry) => isRecord(entry) && entry.name === "twitter:image")) {
+      meta.push({ name: "twitter:image", content: imageSocial });
+    }
+  }
+  if (twitterSite && !meta.some((entry) => isRecord(entry) && entry.name === "twitter:site")) {
+    meta.push({ name: "twitter:site", content: twitterSite });
+  }
+  if (google === false && !meta.some((entry) => isRecord(entry) && entry.name === "robots")) {
+    meta.push({ name: "robots", content: "noindex,nofollow" });
+  }
+  return {
+    ...source,
+    title,
+    meta
+  };
+}
+async function renderBody(page) {
+  const templateKey = page.definition.view.template.toLowerCase();
+  const layoutKey = (page.definition.view.layout || "default").toLowerCase();
+  const TemplateComponent = templates[templateKey];
+  const LayoutComponent = layouts[layoutKey];
+  const fallbackTitle = asString(page.head.title, page.definition.name);
+  const fallbackDescription = asString(page.head.description, "Flow page");
+  if (!TemplateComponent) {
+    const head2 = createHead();
+    head2.push({
+      title: fallbackTitle,
+      meta: [{ name: "description", content: fallbackDescription }]
+    });
+    return {
+      body: `<section class="shell"><div class="shell__panel">Missing template: ${escapeHtml(page.definition.view.template)}</div></section>`,
+      head: head2
+    };
+  }
+  const TemplateRoot = defineComponent({
+    render() {
+      const viewNode = h(TemplateComponent, {
+        page: page.definition,
+        context: page.context,
+        head: page.head,
+        seo: page.seo,
+        locale: page.locale,
+        params: page.params,
+        path: page.pathname
+      });
+      const content = LayoutComponent ? h(LayoutComponent, {}, {
+        default: () => viewNode
+      }) : viewNode;
+      return h(UApp, {}, {
+        default: () => content
+      });
+    }
+  });
+  const app = createSSRApp(TemplateRoot);
+  const head = createHead();
+  head.push(normalizeSeoToHead(page.head, fallbackTitle, fallbackDescription));
+  app.use(head);
+  installFlowVuePlugins(app);
+  return {
+    body: await renderToString(app),
+    head
+  };
+}
+export async function renderDocument(page, clientAssets) {
+  const mode = page.definition.view.mode || "islands";
+  const fallbackTitle = asString(page.head.title, page.definition.name);
+  const fallbackDescription = asString(page.head.description, "Flow page");
+  const boot = {
+    path: page.pathname,
+    bundle: page.definition.view.bundle || "_default",
+    template: page.definition.view.template,
+    title: fallbackTitle,
+    locale: page.locale,
+    mode
+  };
+  const rendered = await renderBody(page);
+  const body = stripVueFragmentMarkers(rendered.body);
+  const baseKey = (page.definition.view.base || "default").toLowerCase();
+  const baseTemplate = bases[baseKey] || bases.default || '<!doctype html><html lang="{{lang}}"><head><meta charset="UTF-8" /><title>{{title}}</title>{{head}}</head><body>{{body}}</body></html>';
+  const pageMarkup = mode === "app" ? `<div id="app" data-page="${escapeHtml(page.definition.name)}" data-template="${escapeHtml(page.definition.view.template)}" data-flow-mode="app">${body}</div>` : body;
+  const html = applyBaseTemplate(baseTemplate, {
+    lang: page.locale.lang,
+    title: fallbackTitle,
+    description: fallbackDescription,
+    head: [
+      `<script id="flow-boot" type="application/json">${serializeBootPayload(boot)}<\/script>`,
+      renderClientHead(clientAssets)
+    ].join("\n    "),
+    body: pageMarkup
+  });
+  return transformHtmlTemplate(rendered.head, html);
+}

package/server/plugins/00.lifecycle.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/server/plugins/00.lifecycle.mjs

@@ -0,0 +1,9 @@
+import { definePlugin } from "nitro";
+export default definePlugin((nitroApp) => {
+  nitroApp.hooks.hook("request", (event) => {
+    const pathname = new URL(event.req.url, "http://localhost").pathname;
+    if (!pathname.startsWith("/api/")) {
+      console.info(`[nitro] request ${pathname}`);
+    }
+  });
+});

package/server/renderer.d.ts

@@ -0,0 +1,3 @@
+export default function renderPage(input: Request | {
+    req?: Request;
+}): Response | Promise<Response> | undefined;

package/server/renderer.mjs

@@ -0,0 +1,14 @@
+function resolveRequest(input) {
+  if (input instanceof Request) {
+    return input;
+  }
+  return input?.req;
+}
+export default function renderPage(input) {
+  const viteEnvs = globalThis.__nitro_vite_envs__;
+  const request = resolveRequest(input);
+  if (!request) {
+    return new Response("Not Found", { status: 404 });
+  }
+  return viteEnvs?.ssr?.fetch(request);
+}

package/server/routes/api/health.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/server/routes/api/health.get.mjs

@@ -0,0 +1,5 @@
+import { defineHandler } from "nitro";
+export default defineHandler(() => ({
+  status: "ok",
+  runtime: "nitro-v3"
+}));

package/server.d.ts

@@ -0,0 +1 @@
+export {};

package/server.mjs

@@ -0,0 +1,32 @@
+interface ViteFetchEnv {
+  fetch(request: Request): Response | Promise<Response>;
+}
+
+type FlowGlobalWithViteEnvs = typeof globalThis & {
+  __nitro_vite_envs__?: Record<string, ViteFetchEnv | undefined>;
+};
+
+function isPageRequest(pathname: string) {
+  if (pathname.startsWith('/api/')) {
+    return false;
+  }
+
+  if (pathname.startsWith('/assets/')) {
+    return false;
+  }
+
+  return !/\.[a-z0-9]+$/i.test(pathname);
+}
+
+export default {
+  async fetch(request: Request) {
+    const pathname = new URL(request.url).pathname;
+
+    if (!isPageRequest(pathname)) {
+      return;
+    }
+
+    const viteEnvs = (globalThis as FlowGlobalWithViteEnvs).__nitro_vite_envs__;
+    return viteEnvs?.ssr?.fetch(request);
+  },
+};

package/src/main.d.ts

@@ -0,0 +1 @@
+export {};

package/src/main.mjs

@@ -0,0 +1,29 @@
+import { hydrateIslands } from "./runtime/islands.mjs";
+import bundles from "virtual:flow/client-pages";
+function readBoot() {
+  const element = document.getElementById("flow-boot");
+  if (!element?.textContent) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(element.textContent);
+  } catch {
+    return void 0;
+  }
+}
+async function bootstrap() {
+  const boot = readBoot();
+  if (boot) {
+    await hydrateIslands(boot);
+  }
+  const bundle = boot?.bundle || "_default";
+  const importer = bundles[bundle] || bundles._default;
+  if (!importer) {
+    return;
+  }
+  const mod = await importer();
+  if (mod.default && boot) {
+    await mod.default(boot);
+  }
+}
+void bootstrap();

package/src/public/boot.d.ts

@@ -0,0 +1 @@
+export type { FlowBootPayload } from '../runtime/boot.ts';

package/src/public/components.d.ts

@@ -0,0 +1 @@
+export { default as FlowIsland } from '../runtime/components/FlowIsland.ts';

package/src/public/components.mjs

@@ -0,0 +1 @@
+export { default as FlowIsland } from "../runtime/components/FlowIsland.mjs";

package/src/public/head.d.ts

@@ -0,0 +1 @@
+export { getClientHead, useHead, useSeoMeta } from '../runtime/head.ts';

package/src/public/head.mjs

@@ -0,0 +1 @@
+export { getClientHead, useHead, useSeoMeta } from "../runtime/head.mjs";

package/src/public/index.d.ts

@@ -0,0 +1,5 @@
+export { defineFlowConfig, defineFlowModule, resolveFlowConfig } from '../runtime/config.ts';
+export { definePage } from '../runtime/pages.ts';
+export type { FlowConfig, FlowLocale, HeadDefinition, PageContextInput, UserFlowConfig, } from '../runtime/config.ts';
+export type { FlowBootPayload } from '../runtime/boot.ts';
+export type { FlowHydrationMode, PageDefinition, PageLocaleDefinition, PageViewDefinition, } from '../runtime/pages.ts';

package/src/public/index.mjs

@@ -0,0 +1,2 @@
+export { defineFlowConfig, defineFlowModule, resolveFlowConfig } from "../runtime/config.mjs";
+export { definePage } from "../runtime/pages.mjs";

package/src/public/modules/content.d.ts

@@ -0,0 +1,2 @@
+export { default } from '../../../modules/content/module.ts';
+export type { ContentModuleOptions } from '../../../modules/content/module.ts';

package/src/public/modules/content.mjs

@@ -0,0 +1 @@
+export { default } from "../../../modules/content/module.mjs";

package/src/public/modules/sitemap.d.ts

@@ -0,0 +1,2 @@
+export { default } from '../../../modules/sitemap/module.ts';
+export type { SitemapModuleOptions } from '../../../modules/sitemap/module.ts';

package/src/public/modules/sitemap.mjs

@@ -0,0 +1 @@
+export { default } from "../../../modules/sitemap/module.mjs";

package/src/public/modules/strapi.d.ts

@@ -0,0 +1,2 @@
+export { default } from '../../../modules/strapi/module.ts';
+export type { StrapiModuleOptions, StrapiVersion } from '../../../modules/strapi/module.ts';

package/src/public/modules/strapi.mjs

@@ -0,0 +1 @@
+export { default } from "../../../modules/strapi/module.mjs";

package/src/public/nitro.d.ts

@@ -0,0 +1,6 @@
+import type { UserFlowConfig } from '../runtime/config.ts';
+export interface CreateFlowNitroConfigOptions {
+    projectRoot?: string;
+    userFlowConfig?: UserFlowConfig;
+}
+export declare function createFlowNitroConfig(options?: CreateFlowNitroConfigOptions): any;