@monkeyplus/flow 5.0.0-rc.99 → 6.0.1

package/modules/strapi/runtime/client.mjs

@@ -0,0 +1,248 @@
+const defaultStrapiConfig = {
+  apiBase: "/api/_strapi",
+  url: process.env.STRAPI_URL || "http://localhost:1337",
+  prefix: "/api",
+  admin: "/admin",
+  version: "v5"
+};
+const defaultServerToken = process.env.STRAPI_TOKEN || void 0;
+export const strapiConfig = { ...defaultStrapiConfig };
+let cachedStrapiConfig = strapiConfig;
+function withLeadingSlash(value) {
+  return value.startsWith("/") ? value : `/${value}`;
+}
+function withoutTrailingSlash(value) {
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function joinUrl(base, path = "") {
+  const normalizedBase = withoutTrailingSlash(base);
+  const normalizedPath = path ? withLeadingSlash(path) : "";
+  return `${normalizedBase}${normalizedPath}`;
+}
+function isAbsoluteUrl(value) {
+  return /^https?:\/\//i.test(value);
+}
+function appendQueryValue(searchParams, key, value) {
+  if (value == null) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => {
+      appendQueryValue(searchParams, `${key}[${index}]`, entry);
+    });
+    return;
+  }
+  if (typeof value === "object") {
+    Object.entries(value).forEach(([childKey, childValue]) => {
+      appendQueryValue(searchParams, `${key}[${childKey}]`, childValue);
+    });
+    return;
+  }
+  searchParams.append(key, String(value));
+}
+function withQuery(url, params) {
+  if (!params || Object.keys(params).length === 0) {
+    return url;
+  }
+  const target = new URL(url);
+  Object.entries(params).forEach(([key, value]) => {
+    appendQueryValue(target.searchParams, key, value);
+  });
+  return target.toString();
+}
+async function getServerRuntimeConfig() {
+  if (typeof window !== "undefined") {
+    return void 0;
+  }
+  const runtime = await import("nitro/runtime-config");
+  return runtime.useRuntimeConfig();
+}
+async function getPublicStrapiConfig() {
+  try {
+    const loaded = await import("virtual:flow/strapi-config");
+    if (loaded?.default) {
+      Object.assign(strapiConfig, {
+        ...defaultStrapiConfig,
+        ...loaded.default
+      });
+      cachedStrapiConfig = strapiConfig;
+    }
+  } catch {
+    Object.assign(strapiConfig, defaultStrapiConfig);
+    cachedStrapiConfig = strapiConfig;
+  }
+  return cachedStrapiConfig;
+}
+async function resolveRestBaseUrl() {
+  const publicConfig = await getPublicStrapiConfig();
+  const runtimeConfig = await getServerRuntimeConfig();
+  const privateConfig = runtimeConfig?.flow?.strapi;
+  if (privateConfig?.url) {
+    return {
+      url: joinUrl(privateConfig.url, privateConfig.prefix),
+      token: privateConfig.token
+    };
+  }
+  if (typeof window !== "undefined") {
+    return {
+      url: publicConfig.apiBase,
+      token: void 0
+    };
+  }
+  if (publicConfig.url) {
+    return {
+      url: joinUrl(publicConfig.url, publicConfig.prefix),
+      token: defaultServerToken
+    };
+  }
+  if (runtimeConfig?.flow?.siteUrl) {
+    return {
+      url: joinUrl(runtimeConfig.flow.siteUrl, publicConfig.apiBase),
+      token: void 0
+    };
+  }
+  return {
+    url: joinUrl("http://localhost:3000", publicConfig.apiBase),
+    token: defaultServerToken
+  };
+}
+async function resolveGraphqlUrl() {
+  const publicConfig = await getPublicStrapiConfig();
+  const runtimeConfig = await getServerRuntimeConfig();
+  const privateConfig = runtimeConfig?.flow?.strapi;
+  if (privateConfig?.url) {
+    return {
+      url: joinUrl(privateConfig.url, "/graphql"),
+      token: privateConfig.token
+    };
+  }
+  if (typeof window !== "undefined") {
+    return {
+      url: joinUrl(publicConfig.apiBase, "/graphql"),
+      token: void 0
+    };
+  }
+  if (publicConfig.url) {
+    return {
+      url: joinUrl(publicConfig.url, "/graphql"),
+      token: defaultServerToken
+    };
+  }
+  if (runtimeConfig?.flow?.siteUrl) {
+    return {
+      url: joinUrl(runtimeConfig.flow.siteUrl, joinUrl(publicConfig.apiBase, "/graphql")),
+      token: void 0
+    };
+  }
+  return {
+    url: joinUrl("http://localhost:3000", joinUrl(publicConfig.apiBase, "/graphql")),
+    token: defaultServerToken
+  };
+}
+function createHeaders(input, token) {
+  const headers = new Headers(input);
+  if (token && !headers.has("authorization")) {
+    headers.set("authorization", `Bearer ${token}`);
+  }
+  if (!headers.has("accept")) {
+    headers.set("accept", "application/json");
+  }
+  return headers;
+}
+async function request(base, path, options = {}) {
+  const resolved = await base();
+  const target = isAbsoluteUrl(path) ? withQuery(path, options.params) : withQuery(joinUrl(resolved.url, path), options.params);
+  const headers = createHeaders(options.headers, resolved.token);
+  const method = options.method || "GET";
+  if ((method === "POST" || method === "PUT" || method === "PATCH") && !headers.has("content-type")) {
+    headers.set("content-type", "application/json");
+  }
+  const response = await fetch(target, {
+    ...options,
+    method,
+    headers
+  });
+  if (!response.ok) {
+    const details = await response.text();
+    throw new Error(`Strapi request failed (${response.status} ${response.statusText}): ${details}`);
+  }
+  if (response.status === 204) {
+    return void 0;
+  }
+  const contentType = response.headers.get("content-type") || "";
+  return contentType.includes("application/json") ? await response.json() : await response.text();
+}
+export function useStrapiVersion() {
+  return cachedStrapiConfig.version;
+}
+export function useStrapiUrl(path = "") {
+  return cachedStrapiConfig.url ? joinUrl(joinUrl(cachedStrapiConfig.url, cachedStrapiConfig.prefix), path) : joinUrl(cachedStrapiConfig.apiBase, path);
+}
+export function useStrapiAdminUrl(path = "") {
+  return cachedStrapiConfig.url ? joinUrl(joinUrl(cachedStrapiConfig.url, cachedStrapiConfig.admin), path) : joinUrl(cachedStrapiConfig.admin, path);
+}
+export function useStrapiMedia(url) {
+  if (!url) {
+    return url;
+  }
+  if (isAbsoluteUrl(url) || !cachedStrapiConfig.url) {
+    return url;
+  }
+  return new URL(url, cachedStrapiConfig.url).toString();
+}
+export function useStrapiClient() {
+  return async function strapiClient(url, options) {
+    return await request(resolveRestBaseUrl, url, options);
+  };
+}
+export function useStrapi() {
+  const client = useStrapiClient();
+  return {
+    async find(contentType, params, options) {
+      return await client(contentType, {
+        ...options,
+        params
+      });
+    },
+    async findOne(contentType, documentId, params, options) {
+      return await client(`${contentType}/${documentId}`, {
+        ...options,
+        params
+      });
+    },
+    async create(contentType, data, params, options) {
+      return await client(contentType, {
+        ...options,
+        method: "POST",
+        body: JSON.stringify({ data }),
+        params
+      });
+    },
+    async update(contentType, documentId, data, params, options) {
+      return await client(`${contentType}/${documentId}`, {
+        ...options,
+        method: "PUT",
+        body: JSON.stringify({ data: data || {} }),
+        params
+      });
+    },
+    async delete(contentType, documentId, params, options) {
+      const target = documentId ? `${contentType}/${documentId}` : contentType;
+      return await client(target, {
+        ...options,
+        method: "DELETE",
+        params
+      });
+    }
+  };
+}
+export function useStrapiGraphQL() {
+  return async function strapiGraphQL(query, variables, options) {
+    const source = typeof query === "string" ? query : query.loc?.source?.body || "";
+    return await request(resolveGraphqlUrl, "", {
+      ...options,
+      method: "POST",
+      body: JSON.stringify({ query: source, variables })
+    });
+  };
+}

package/package.json

@@ -1,86 +1,82 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "5.0.0-rc.99",
+  "version": "6.0.1",
+  "description": "@monkeyplus/flow package-first runtime with Vite, Nitro, Vue and a workspace playground.",
   "license": "MIT",
-  "type": "module",
-  "main": "./dist/index.mjs",
-  "types": "./types.d.ts",
-  "bin": {
-    "flow": "./bin/flow.mjs"
+  "publishConfig": {
+    "access": "public"
   },
+  "type": "module",
   "exports": {
-    ".": "./dist/index.mjs",
-    "./app": "./dist/app/index.mjs",
+    ".": {
+      "types": "./src/public/index.d.ts",
+      "import": "./src/public/index.mjs"
+    },
+    "./vite": {
+      "types": "./src/public/vite.d.ts",
+      "import": "./src/public/vite.mjs"
+    },
+    "./nitro": {
+      "types": "./src/public/nitro.d.ts",
+      "import": "./src/public/nitro.mjs"
+    },
+    "./head": {
+      "types": "./src/public/head.d.ts",
+      "import": "./src/public/head.mjs"
+    },
+    "./vue": {
+      "types": "./src/public/vue.d.ts",
+      "import": "./src/public/vue.mjs"
+    },
+    "./boot": {
+      "types": "./src/public/boot.d.ts",
+      "import": "./src/public/boot.mjs"
+    },
+    "./components": {
+      "types": "./src/public/components.d.ts",
+      "import": "./src/public/components.mjs"
+    },
+    "./strapi": {
+      "types": "./modules/strapi/runtime/client.d.ts",
+      "import": "./modules/strapi/runtime/client.mjs"
+    },
+    "./modules/sitemap": {
+      "types": "./src/public/modules/sitemap.d.ts",
+      "import": "./src/public/modules/sitemap.mjs"
+    },
+    "./modules/strapi": {
+      "types": "./src/public/modules/strapi.d.ts",
+      "import": "./src/public/modules/strapi.mjs"
+    },
+    "./modules/content": {
+      "types": "./src/public/modules/content.d.ts",
+      "import": "./src/public/modules/content.mjs"
+    },
+    "./main": {
+      "types": "./src/main.d.ts",
+      "import": "./src/main.mjs"
+    },
+    "./entry-server": {
+      "types": "./entry-server.d.ts",
+      "import": "./entry-server.mjs"
+    },
+    "./styles.css": "./src/styles.css",
     "./package.json": "./package.json"
   },
-  "imports": {
-    "#app": "./dist/app/index.mjs",
-    "#head": "./dist/head/runtime/index.mjs",
-    "#pages": "./dist/pages/runtime/index.mjs"
-  },
-  "files": [
-    "app.d.ts",
-    "bin",
-    "types.d.ts",
-    "dist"
-  ],
+  "main": "./src/public/index.mjs",
+  "types": "./src/public/index.d.ts",
   "dependencies": {
-    "@monkeyplus/flow-cli": "5.0.0-rc.99",
-    "@monkeyplus/flow-kit": "5.0.0-rc.99",
-    "@monkeyplus/flow-schema": "5.0.0-rc.99",
-    "@rollup/plugin-replace": "^4.0.0",
-    "@vueuse/head": "^0.7.6",
-    "c12": "^0.2.8",
-    "chokidar": "^3.5.3",
-    "consola": "^2.15.3",
-    "defu": "^6.0.0",
-    "esbuild": "^0.14.49",
-    "escape-string-regexp": "^5.0.0",
-    "esno": "^0.16.3",
-    "eta": "^1.12.3",
-    "externality": "^0.2.2",
-    "fs-extra": "^10.1.0",
-    "get-port-please": "^2.5.0",
-    "globby": "^13.1.2",
-    "h3": "^0.7.16",
-    "hookable": "^5.1.1",
-    "jiti": "^1.14.0",
-    "ohash": "^0.1.5",
-    "knitwork": "^0.1.2",
-    "listhen": "^0.2.13",
-    "magic-string": "^0.26.2",
-    "mlly": "^0.5.4",
-    "mri": "^1.2.0",
-    "nitropack": "^0.4.12",
-    "pathe": "^0.3.2",
-    "perfect-debounce": "^0.1.3",
-    "radix3": "^0.1.2",
-    "unenv": "^0.5.2",
-    "ohmyfetch": "^0.4.18",
-    "node-fetch-native": "^0.1.4",
-    "rollup": "^2.77.0",
-    "rollup-plugin-visualizer": "^5.7.1",
-    "scule": "^0.2.1",
-    "ufo": "^0.8.5",
-    "unctx": "^2.0.1",
-    "unimport": "^0.4.5",
-    "unplugin": "^0.9.4",
-    "untyped": "^0.4.5",
-    "pkg-types": "^0.3.3",
-    "vite": "~3.0.9",
-    "vite-node": "^0.22.1",
-    "vite-plugin-checker": "^0.4.9",
-    "vue-bundle-renderer": "^0.4.2",
-    "vue": "^3.2.37"
-  },
-  "devDependencies": {
-    "@types/fs-extra": "^9.0.13",
-    "vue-router": "^4.1.2"
-  },
-  "engines": {
-    "node": "^16.11.0 || ^17.0.0 || ^18.0.0"
-  },
-  "scripts": {
-    "stub": "unbuild --stub"
+    "@iconify/json": "^2.2.471",
+    "@nuxt/ui": "^4.7.1",
+    "@unhead/ssr": "^3.1.0",
+    "@unhead/vue": "^3.1.0",
+    "@vitejs/plugin-vue": "^6.0.5",
+    "@vue/server-renderer": "^3.5.13",
+    "nitro": "3.0.260429-beta",
+    "std-env": "^4.0.0",
+    "unhead": "^3.1.0",
+    "unplugin-icons": "^23.0.1",
+    "vite": "^8.0.5",
+    "vue": "^3.5.13"
   }
-}
+}

package/server/lib/handler.d.ts

@@ -0,0 +1 @@
+export declare function renderPageRequest(request: Request): Promise<Response>;

package/server/lib/handler.mjs

@@ -0,0 +1,43 @@
+import clientAssets from "../../src/main.mjs?assets=client";
+import bundleAssets from "virtual:flow/client-page-assets";
+import { renderDocument } from "./render.mjs";
+import { resolvePage, resolvePageByName } from "./pages.mjs";
+function mergeClientAssets(baseAssets, pageAssets) {
+  const css = [...baseAssets.css || [], ...pageAssets?.css || []];
+  const js = [...baseAssets.js || [], ...pageAssets?.js || []];
+  return {
+    entry: baseAssets.entry,
+    css: css.filter((asset, index, list) => list.findIndex((candidate) => candidate.href === asset.href) === index),
+    js: js.filter((asset, index, list) => list.findIndex((candidate) => candidate.href === asset.href) === index)
+  };
+}
+export async function renderPageRequest(request) {
+  const pathname = new URL(request.url).pathname;
+  const page = await resolvePage(pathname);
+  if (!page) {
+    const notFoundPage = await resolvePageByName("error404", pathname);
+    if (!notFoundPage) {
+      return new Response("Not Found", {
+        status: 404,
+        headers: {
+          "content-type": "text/plain; charset=utf-8"
+        }
+      });
+    }
+    const bundleName2 = notFoundPage.definition.view.bundle || "_default";
+    const resolvedAssets2 = mergeClientAssets(clientAssets, bundleAssets[bundleName2] || bundleAssets._default);
+    return new Response(await renderDocument(notFoundPage, resolvedAssets2), {
+      status: 404,
+      headers: {
+        "content-type": "text/html; charset=utf-8"
+      }
+    });
+  }
+  const bundleName = page.definition.view.bundle || "_default";
+  const resolvedAssets = mergeClientAssets(clientAssets, bundleAssets[bundleName] || bundleAssets._default);
+  return new Response(await renderDocument(page, resolvedAssets), {
+    headers: {
+      "content-type": "text/html; charset=utf-8"
+    }
+  });
+}

package/server/lib/pages.d.ts

@@ -0,0 +1,20 @@
+import type { DynamicRouteEntry, FlowLocale, GetUrlOptions, HeadDefinition, PageDefinition, PageLocaleDefinition, PageUrlInfo } from '../../src/runtime/pages';
+export interface ResolvedPage {
+    definition: PageDefinition;
+    locale: FlowLocale;
+    localeCode: string;
+    localePage: PageLocaleDefinition;
+    pathname: string;
+    params: Record<string, string>;
+    dynamic?: DynamicRouteEntry;
+    head: HeadDefinition;
+    /**
+     * @deprecated Use head.
+     */
+    seo: HeadDefinition;
+    context: Record<string, unknown>;
+}
+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): Promise<ResolvedPage | undefined>;
+export declare function resolvePageByName(name: string, pathname: string): Promise<ResolvedPage | undefined>;