@monkeyplus/flow 5.0.0-rc.233 → 5.0.0-rc.24

package/dist/pages/runtime/helpers/index.d.ts

@@ -1,5 +1,5 @@
 import type { GetPages, PageDefinition } from '@monkeyplus/flow-schema';
 export declare function definePage(page: PageDefinition): {
-    pages: never[];
+    pages: any[];
     getPages: GetPages;
 };

package/dist/pages/runtime/helpers/index.mjs

@@ -1,9 +1,6 @@
 import { joinURL, withTrailingSlash } from "ufo";
-const buildPages = (page) => (location, language, _locales) => {
-  const locales = _locales.map((key) => {
-    const _page = page.locales[key];
-    return [key, _page];
-  }).filter((el) => !!el[1]);
+const buildPages = (page) => (location, language) => {
+  const locales = Object.entries(page.locales);
   return locales.map(([locale, localePage]) => {
     const [_language, _location] = locale.split("-");
     const name = joinURL("/", _location, _language, page.name);
@@ -19,15 +16,7 @@ const buildPages = (page) => (location, language, _locales) => {
     return {
       name,
       url: path,
-      context: {
-        page: localePage,
-        locale: _locale,
-        path,
-        view: page.view,
-        name: page.name,
-        noPublish: page.noPublish
-      }
-      // locale: _locale,
+      context: { page: localePage, locale: _locale, path, view: page.view, name: page.name }
     };
   });
 };

package/dist/pages/runtime/index.d.ts

@@ -1,10 +1,9 @@
 import type { DynamicPage, PageCtx, SimplePage } from '@monkeyplus/flow-schema';
 export declare function definePage<T>(...pages: SimplePage<T>[]): SimplePage<T>[];
-export declare function defineDynamicPage<T>(...pages: DynamicPage<T>[]): DynamicPage<T>[];
-export interface SharedContext {
+export declare function defineDinamycPage<T>(...pages: DynamicPage<T>[]): DynamicPage<T>[];
+interface SharedContext {
     assign?: 'global' | 'local';
-    merge?: boolean;
     setup: (cxt: PageCtx) => any;
-    locales?: Record<string, (ctx: PageCtx) => any>;
 }
 export declare function defineSharedContext(shared: SharedContext): SharedContext;
+export {};

package/dist/pages/runtime/index.mjs

@@ -1,9 +1,8 @@
 export function definePage(...pages) {
   return pages;
 }
-export function defineDynamicPage(...pages) {
+export function defineDinamycPage(...pages) {
   return pages.map((page) => {
-    page.originalName = page.name;
     if (!page.name.endsWith("/**"))
       page.name = `${page.name}/**`;
     return page;

package/dist/pages/runtime/pages.mjs

@@ -16,104 +16,58 @@ export default defineFlowPlugin(async (flow) => {
         name,
         ...page
       });
-      const _pages2 = getPages(
-        app.locale.location,
-        app.locale.language,
-        app.locale.locales
-      );
+      const _pages2 = getPages(app.locale.location, app.locale.language);
       _pages2.forEach((page2) => {
         flow.router.byUrl.insert(page2.url, page2.context);
-        if (page2.url.includes("**") && !page2.context.page.dynamic) {
-          const _url = page2.url.replaceAll("*", "");
-          flow.router.byUrl.insert(_url, {
-            ...page2.context,
-            path: _url
-          });
-        }
         flow.router.byName.insert(page2.name, page2.context);
         allPages.push(page2.context);
       });
     });
   });
   const cache = {};
-  const cacheData = {};
-  function replacePath(_path, url) {
-    if (typeof url === "string") {
-      _path = joinURL(_path.replace("/**", ""), url);
-    } else {
-      Object.entries(url).forEach(([key, value]) => {
-        _path = _path.replace(`:${key}`, value);
-      });
-      if (url._ && _path.endsWith("**"))
-        _path = joinURL(_path.replace("/**", ""), url._);
-    }
-    return _path;
-  }
   async function getUrl(namePage, localeCode) {
     const code = localeCode || this?.getLocale()?.code;
     const [lang, loc] = code.split("-");
     const name = joinURL("/", loc, lang, namePage);
-    const baseHome = joinURL("/", loc, lang, "home");
     const { path, params, page } = flow.router.byName.lookup(name) || {};
-    const h = flow.router.byName.lookup(baseHome);
-    const base404 = h?.path || "/";
     if (params?._ && page.dynamic) {
-      if (!cache[path + code]) {
-        if (flow.generate) {
-          cache[path + code] = async (_ctx, _path) => {
-            if (cacheData[_path])
-              return cacheData[_path];
-            const r = await page.dynamic.method(_ctx);
-            cacheData[_path] = r;
-            return r;
-          };
-        } else {
-          cache[path + code] = this.defineCachedFunction(async (_ctx) => {
-            return await page.dynamic.method(_ctx);
-          }, { maxAge: 20, getKey: (_ctx, _path) => _path, swr: false });
-        }
+      if (!cache[path]) {
+        cache[path] = this.defineCachedFunction(async (_ctx) => {
+          return await page.dynamic.method(_ctx);
+        }, { maxAge: 8, getKey: () => path, swr: false });
       }
-      const fn = cache[path + code];
-      const list = await fn({ utils: this, locale: { ...this.getLocale(), code } }, path);
+      const fn = cache[path];
+      const list = await fn({ utils: this, locale: this.getLocale() });
       const dPage = list.find((el) => el.name === params._);
-      return dPage ? replacePath(path, dPage.url) : `${base404}404`;
+      return dPage ? path.replace("**", dPage.url) : "/404";
     }
-    return path?.replaceAll("*", "") || `${base404}404`;
+    return path || "/404";
   }
-  async function getUrls(withLocale = false, omitNoPublish = false) {
+  async function getUrls(withLocale = false) {
     const urls = [];
-    const _allPages = allPages.filter((p) => omitNoPublish ? !p.noPublish : true);
-    for (const page of _allPages) {
-      if ((page.path.includes("/:") || page.path.includes("/**")) && page.page.dynamic) {
+    for (const page of allPages) {
+      if (!page.path.includes("/**")) {
+        urls.push(withLocale ? { url: page.path, locale: page.locale.code, name: page.name } : page.path);
+      } else {
         const dPages = await page.page.dynamic.method({
           locale: page.locale,
-          utils: Object.assign({ getLocale: () => page.locale }, flow.app.utils),
-          chunks: {},
-          page: {}
+          utils: Object.assign({ getLocale: () => page.locale }, flow.app.utils)
         });
         dPages.forEach((dPage) => {
-          const _path = replacePath(page.path, dPage.url);
-          urls.push(withLocale ? { url: _path, locale: page.locale.code, name: joinURL(page.name?.replaceAll("*", ""), dPage.name) } : _path);
+          const _path = joinURL(page.path.replace("/**", ""), dPage.url);
+          urls.push(withLocale ? { url: _path, locale: page.locale.code, name: joinURL(page.name, dPage.name) } : _path);
         });
-      } else {
-        const url = page.path.replaceAll("*", "");
-        urls.push(withLocale ? { url, locale: page.locale.code, name: page.name } : url);
       }
     }
     return urls.sort();
   }
-  async function getSharedContext(ctx) {
+  async function getSharedContext(utils) {
     const entries = Object.entries(contexts);
     if (!entries.length)
       return {};
     const _contexts = await Promise.all(entries.map(async ([key, method]) => {
-      const data = await method.setup(ctx);
-      const setupLocal = method?.locales?.[ctx.locale.code];
-      let dataLocal = {};
-      if (setupLocal)
-        dataLocal = await setupLocal(ctx);
-      const obj = method.merge ? { ...data, ...dataLocal } : { [key]: { ...data, ...dataLocal } };
-      return obj;
+      const data = await method.setup(utils);
+      return { [key]: data };
     }));
     return _contexts.reduce((acc, curr) => {
       return {

package/dist/vite-client/runtime/injectManifest.d.ts

@@ -0,0 +1,26 @@
+export declare type Manifest = Record<string, ManifestChunk>;
+export interface ManifestChunk {
+    src?: string;
+    file: string;
+    css?: string[];
+    assets?: string[];
+    isEntry?: boolean;
+    isDynamicEntry?: boolean;
+    imports?: string[];
+    dynamicImports?: string[];
+}
+export interface HtmlTagDescriptor {
+    tag: string;
+    attrs?: Record<string, string | boolean | undefined>;
+    children?: string | HtmlTagDescriptor[];
+    /**
+     * default: 'head-prepend'
+     */
+    injectTo?: 'head' | 'body' | 'head-prepend' | 'body-prepend';
+}
+export declare const generateBundle: (config: any, bundle: Manifest, _id: string) => {
+    head: string;
+    body: string;
+};
+export declare const externalRE: RegExp;
+export declare const isExternalUrl: (url: string) => boolean;

package/dist/vite-client/runtime/injectManifest.mjs

@@ -0,0 +1,104 @@
+import { joinURL } from "ufo";
+export const generateBundle = (config, bundle, _id) => {
+  const analyzedChunk = new Map();
+  const getImportedChunks = (chunk2, seen = new Set()) => {
+    const chunks = [];
+    chunk2.imports?.forEach((file) => {
+      const importee = bundle[file];
+      if (file.startsWith("_") && !seen.has(file)) {
+        seen.add(file);
+        chunks.push(...getImportedChunks(importee, seen));
+        chunks.push(importee);
+      }
+    });
+    return chunks;
+  };
+  const toScriptTag = (chunk2, publicBase2, isAsync2) => ({
+    tag: "script",
+    attrs: {
+      ...isAsync2 ? { async: true } : {},
+      type: "module",
+      crossorigin: true,
+      src: toPublicPath(chunk2.file, publicBase2)
+    }
+  });
+  const toPreloadTag = (chunk2, publicBase2) => ({
+    tag: "link",
+    attrs: {
+      rel: "modulepreload",
+      crossorigin: true,
+      href: toPublicPath(chunk2.file, publicBase2)
+    }
+  });
+  const getCssTagsForChunk = (chunk2, publicBase2, seen = new Set()) => {
+    const tags = [];
+    if (!analyzedChunk.has(chunk2)) {
+      analyzedChunk.set(chunk2, 1);
+      chunk2.imports?.forEach((file) => {
+        const importee = bundle[file];
+        if (file.startsWith("_"))
+          tags.push(...getCssTagsForChunk(importee, publicBase2, seen));
+      });
+    }
+    chunk2.css?.forEach((file) => {
+      if (!seen.has(file)) {
+        seen.add(file);
+        tags.push({
+          tag: "link",
+          attrs: {
+            rel: "stylesheet",
+            href: toPublicPath(file, publicBase2)
+          }
+        });
+      }
+    });
+    return tags;
+  };
+  const publicBase = config.baseURL || "/";
+  const isAsync = false;
+  const chunk = Object.values(bundle).find((chunk2) => chunk2.isEntry && chunk2.src === _id);
+  if (chunk) {
+    const imports = getImportedChunks(chunk);
+    const assetTags = [
+      toScriptTag(chunk, publicBase, isAsync),
+      ...imports.map((i) => toPreloadTag(i, publicBase))
+    ];
+    assetTags.push(...getCssTagsForChunk(chunk, publicBase));
+    const tags = serializeTags(assetTags);
+    return { head: tags, body: "" };
+  }
+};
+export const externalRE = /^(https?:)?\/\//;
+export const isExternalUrl = (url) => externalRE.test(url);
+function toPublicPath(filename, publicBase) {
+  return isExternalUrl(filename) ? filename : joinURL(publicBase, filename.replace("scripts", "assets"));
+}
+const unaryTags = new Set(["link", "meta", "base"]);
+function serializeTag({ tag, attrs, children }, indent = "") {
+  if (unaryTags.has(tag)) {
+    return `<${tag}${serializeAttrs(attrs)}>`;
+  } else {
+    return `<${tag}${serializeAttrs(attrs)}>${serializeTags(children, incrementIndent(indent))}</${tag}>`;
+  }
+}
+function serializeTags(tags, indent = "") {
+  if (typeof tags === "string")
+    return tags;
+  else if (tags && tags.length)
+    return tags.map((tag) => `${indent}${serializeTag(tag, indent)}
+`).join("");
+  return "";
+}
+function serializeAttrs(attrs) {
+  let res = "";
+  for (const key in attrs) {
+    if (typeof attrs[key] === "boolean")
+      res += attrs[key] ? ` ${key}` : "";
+    else
+      res += ` ${key}=${JSON.stringify(attrs[key])}`;
+  }
+  return res;
+}
+function incrementIndent(indent = "") {
+  return `${indent}${indent[0] === "	" ? "	" : "  "}`;
+}

package/dist/vite-client/runtime/plugin.d.ts

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

package/dist/vite-client/runtime/plugin.mjs

@@ -0,0 +1,26 @@
+import logger from "consola";
+import { generateBundle } from "./injectManifest.mjs";
+import { defineFlowPlugin } from "#app";
+import manifest from "#viteManifest";
+export default defineFlowPlugin((flow) => {
+  if (typeof manifest === "function") {
+    flow.hook("page:chunks", (bundle, chunks) => {
+      try {
+        const chunk = generateBundle(flow.$config.app || {}, manifest(), `client/pages/${bundle}.ts`);
+        if (chunk) {
+          chunks.head.push(chunk.head);
+          chunks.body.push(chunk.body);
+        } else {
+          logger.warn('Entry "%s" not found ', bundle);
+        }
+      } catch (error) {
+        logger.error("Error in inject %s ", bundle);
+      }
+    });
+  } else {
+    flow.hook("page:chunks", (bundle, chunks) => {
+      chunks.head.push(manifest.head());
+      chunks.body.push(manifest.body(bundle));
+    });
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "5.0.0-rc.233",
+  "version": "5.0.0-rc.24",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -25,56 +25,52 @@
     "dist"
   ],
   "dependencies": {
+    "@monkeyplus/flow-cli": "5.0.0-rc.24",
+    "@monkeyplus/flow-kit": "5.0.0-rc.24",
+    "@monkeyplus/flow-schema": "5.0.0-rc.24",
     "@rollup/plugin-replace": "^4.0.0",
-    "@vueuse/head": "^1.0.16",
-    "c12": "^1.0.1",
+    "@vueuse/head": "^0.7.6",
+    "c12": "^0.2.7",
     "chokidar": "^3.5.3",
     "consola": "^2.15.3",
-    "defu": "^6.1.0",
-    "esbuild": "^0.15.13",
+    "defu": "^6.0.0",
+    "esbuild": "^0.14.38",
     "escape-string-regexp": "^5.0.0",
-    "esno": "^0.16.3",
+    "esno": "^0.14.1",
     "eta": "^1.12.3",
-    "externality": "^1.0.0",
+    "externality": "^0.2.1",
     "fs-extra": "^10.1.0",
-    "globby": "^13.1.2",
-    "h3": "^1.8.0",
-    "hookable": "^5.4.2",
-    "jiti": "^1.19.0",
-    "ohash": "^1.0.0",
-    "knitwork": "^1.0.0",
-    "listhen": "^1.0.0",
-    "magic-string": "^0.26.7",
-    "mlly": "^1.0.0",
+    "get-port-please": "^2.5.0",
+    "globby": "^13.1.1",
+    "h3": "^0.7.4",
+    "hookable": "^5.1.1",
+    "jiti": "^1.13.0",
+    "knitwork": "^0.1.1",
+    "listhen": "^0.2.10",
+    "magic-string": "^0.26.2",
+    "mlly": "^0.5.2",
     "mri": "^1.2.0",
-    "nitropack": "1.0.0",
-    "pathe": "^1.0.0",
+    "nitropack": "^0.4.4",
+    "pathe": "^0.2.0",
     "perfect-debounce": "^0.1.3",
-    "radix3": "^1.0.0",
-    "unenv": "^1.0.0",
-    "ohmyfetch": "^0.4.21",
-    "node-fetch-native": "^1.0.1",
-    "rollup": "^3.10.1",
-    "rollup-plugin-visualizer": "^5.8.3",
-    "scule": "^1.0.0",
-    "ufo": "^1.0.0",
-    "unctx": "^2.1.0",
-    "unimport": "^1.0.1",
-    "unplugin": "^1.0.0",
-    "untyped": "^1.0.0",
-    "pkg-types": "^1.0.1",
-    "vite": "~4.0.4",
-    "vite-node": "^0.24.5",
-    "vite-plugin-checker": "^0.5.1",
-    "vue-bundle-renderer": "^1.0.0",
-    "vue": "^3.2.41",
-    "@monkeyplus/flow-cli": "5.0.0-rc.233",
-    "@monkeyplus/flow-kit": "5.0.0-rc.233",
-    "@monkeyplus/flow-schema": "5.0.0-rc.233"
+    "radix3": "^0.1.2",
+    "unenv": "^0.5.2",
+    "ohmyfetch": "^0.4.18",
+    "node-fetch-native": "^0.1.3",
+    "rollup": "^2.72.1",
+    "rollup-plugin-visualizer": "^5.6.0",
+    "scule": "^0.2.1",
+    "ufo": "^0.8.3",
+    "unctx": "^1.1.4",
+    "unimport": "^0.2.1",
+    "unplugin": "^0.6.3",
+    "untyped": "^0.4.4",
+    "vite": "^2.9.9",
+    "vue": "^3.2.33"
   },
   "devDependencies": {
     "@types/fs-extra": "^9.0.13",
-    "vue-router": "^4.1.6"
+    "vue-router": "^4.0.15"
   },
   "engines": {
     "node": "^16.11.0 || ^17.0.0 || ^18.0.0"

package/dist/app/entry.async.d.ts

@@ -1,3 +0,0 @@
-import type { RuntimeConfig } from '@monkeyplus/flow-schema';
-declare const _default: (ctx?: RuntimeConfig) => Promise<any>;
-export default _default;

package/dist/app/entry.async.mjs

@@ -1 +0,0 @@
-export default (ctx) => import("#app/entry").then((m) => m.default(ctx));