@monkeyplus/flow 4.0.0-beta.9 → 5.0.0-beta.10

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

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

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

@@ -0,0 +1,28 @@
+import { joinURL, withTrailingSlash } from "ufo";
+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);
+    const defLocation = _location === location ? "" : _location;
+    const defLanguage = _language === language ? "" : _language;
+    const url = joinURL("/", defLocation, defLanguage, localePage.url);
+    const _locale = {
+      lang: _language,
+      loc: _location,
+      code: locale
+    };
+    const path = localePage.url.endsWith("/") ? withTrailingSlash(url) : url;
+    return {
+      name,
+      url: path,
+      context: { page: localePage, locale: _locale, path, view: page.view, name }
+    };
+  });
+};
+export function definePage(page) {
+  return {
+    pages: [],
+    getPages: buildPages(page)
+  };
+}

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

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

package/dist/pages/runtime/plugin.mjs

@@ -0,0 +1,51 @@
+import { joinURL } from "ufo";
+import { definePage } from "./helpers/index.mjs";
+import { defineFlowPlugin, useRuntimeConfig } from "#app";
+import pages from "#pages";
+export default defineFlowPlugin(async (flow) => {
+  const { app } = useRuntimeConfig();
+  const allPages = [];
+  Object.entries(pages).forEach(([name, page]) => {
+    const { getPages } = definePage({
+      name,
+      ...page
+    });
+    const _pages = getPages(app.locale.location, app.locale.language);
+    _pages.forEach((page2) => {
+      flow.router.byUrl.insert(page2.url, page2.context);
+      flow.router.byName.insert(page2.name, page2.context);
+      allPages.push(page2.context);
+    });
+  });
+  function getUrl(namePage, localeCode) {
+    const code = localeCode || this?.getLocale()?.code;
+    const [lang, loc] = code.split("-");
+    const name = joinURL("/", loc, lang, namePage);
+    const { path } = flow.router.byName.lookup(name) || {};
+    return path || "/404";
+  }
+  async function getUrls() {
+    const urls = [];
+    for (const page of allPages) {
+      if (!page.path.includes("/**")) {
+        urls.push(page.path);
+      } else {
+        const dPages = await page.page.dynamic.method({
+          locale: page.locale,
+          utils: Object.assign({ getLocale: () => page.locale }, flow.app.utils)
+        });
+        dPages.forEach((dPage) => {
+          urls.push(joinURL(page.path.replace("/**", ""), dPage.url));
+        });
+      }
+    }
+    return urls.sort();
+  }
+  flow.setUtil("getUrl", getUrl);
+  flow.setUtil("getUrls", getUrls);
+  return {
+    provide: {
+      pages: { allPages }
+    }
+  };
+});

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,27 @@
+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") {
+    const _manifest = manifest();
+    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,51 +1,69 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "4.0.0-beta.9",
-  "description": "Utils hapi",
-  "author": "Andres Navarrete",
+  "version": "5.0.0-beta.10",
   "license": "MIT",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist/",
-    "types/"
-  ],
+  "type": "module",
   "exports": {
-    ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
-    }
+    ".": "./dist/index.mjs",
+    "./app": "./dist/app/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "types": "./types.d.ts",
+  "bin": {
+    "flow": "./bin/flow.mjs"
   },
   "dependencies": {
-    "@hapi/boom": "9.x.x",
-    "@hapi/hoek": "9.x.x",
-    "consola": "^2.15.3",
-    "chalk": "^4.1.2",
+    "@monkeyplus/flow-cli": "5.0.0-beta.10",
+    "@monkeyplus/flow-kit": "5.0.0-beta.10",
+    "@monkeyplus/flow-schema": "5.0.0-beta.10",
+    "@rollup/plugin-replace": "^4.0.0",
+    "@vueuse/head": "^0.7.6",
+    "c12": "^0.2.7",
     "chokidar": "^3.5.3",
+    "consola": "^2.15.3",
+    "defu": "^6.0.0",
+    "esbuild": "^0.14.38",
+    "escape-string-regexp": "^5.0.0",
+    "esno": "^0.14.1",
+    "eta": "^1.12.3",
+    "externality": "^0.2.1",
+    "fs-extra": "^10.1.0",
+    "get-port-please": "^2.5.0",
+    "globby": "^13.1.1",
+    "h3": "^0.7.4",
     "hookable": "^5.1.1",
-    "fs-extra": "^10.0.0",
-    "ramda": "^0.28.0"
+    "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": "^0.4.4",
+    "pathe": "^0.2.0",
+    "perfect-debounce": "^0.1.3",
+    "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",
-    "@types/hapi__hapi": "^20.0.10",
-    "@types/hapi__nes": "^11.0.5",
-    "@types/hapi__vision": "^5.5.3",
-    "@types/ramda": "^0.27.64"
+    "@types/fs-extra": "^9.0.13"
   },
-  "peerDependencies": {
-    "@hapi/hapi": "^20.x"
+  "engines": {
+    "node": "^16.11.0 || ^17.0.0 || ^18.0.0"
   },
-  "gitHead": "1d5387b9c77909019f36d360a0ac53ddaa40e4af",
   "scripts": {
-    "build": "unbuild",
-    "dev": "pnpm stub && pnpm types",
-    "stub": "unbuild --stub",
-    "types": "tsup ./src/index.ts --dts-only --external types && esno ../../scripts/replace",
-    "lint": "eslint --ext .js,.ts .",
-    "fix": "eslint --fix --ext .ts .",
-    "start": "esno src/index.ts",
-    "test": "vitest"
+    "stub": "unbuild --stub"
   }
 }

package/src/app/composables/index.ts

@@ -0,0 +1,20 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+//* fake to nuxt Compatibilities
+
+export function useCookie(name: string, _opts?: any) {
+  // console.log('Cookie', name, _opts);
+
+  return {};
+}
+
+export function refreshNuxtData(keys?: string | string[]): Promise<void> {
+  return Promise.resolve();
+}
+
+export function useAsyncData(key: string, handlers: () => Promise<any>) {
+  return handlers();
+}
+
+export function useRoute() {
+  return {};
+}

package/src/app/entry.ts

@@ -0,0 +1,36 @@
+
+import type { RuntimeConfig } from '@monkeyplus/flow-schema';
+import { config, configure, render } from 'eta';
+import { applyPlugins, createFlowApp } from './flow';
+// @ts-ignore
+import plugins from '#build/plugins';
+
+export default async(runtimeConfig: RuntimeConfig) => {
+  const flow = createFlowApp({ runtimeConfig });
+  try {
+    await applyPlugins(flow, plugins);
+    // console.log(flow.eta);
+
+    configure(flow.eta);
+    flow.render = (view: Record<string, string>, data: any) => {
+      // eslint-disable-next-line no-template-curly-in-string
+      const layout = '<%layout(`layouts/${it.view?.layout||\'default\'}`)%>';
+      const getTemplate = flow.engines[view.engine || flow.engine];
+      const base = `${layout}
+      ${getTemplate(view.template)}`;
+      return render(base, data || {}, {
+        ...config,
+        async: true,
+      });
+    };
+
+    // await flow.hooks.callHook('app:created', vueApp);
+  }
+  catch (err) {
+    console.log(err);
+    // await flow.callHook('app:error', err);
+    // ssrContext.error = ssrContext.error || err;
+  }
+
+  return flow;
+};

package/src/app/flow.ts

@@ -0,0 +1,157 @@
+import type { RadixRouter } from 'radix3';
+import { createRouter } from 'radix3';
+import type { Hookable } from 'hookable';
+import { createHooks } from 'hookable';
+import type { FlowPage, RuntimeConfig } from '@monkeyplus/flow-schema';
+import { getContext } from 'unctx';
+import { globby } from 'globby';
+import { join, resolve } from 'pathe';
+
+const flowAppCtx = getContext<FlowApp>('flow-app');
+
+type HookResult = Promise<void> | void;
+export interface FlowAppHooks{
+  'flow:pages': (page: FlowPage[]) => HookResult
+  'eta:plugin': (options: any) => HookResult
+  'page:scripts': (scripts: { head: string[]; bodyEnd: string[]; bodyStart: string[] }) => HookResult
+  'page:links': (links: string[]) => HookResult
+  'page:chunks': (bundle: string, scripts: { head: string[]; body: string[] }) => HookResult
+  'page:generate': (generate: any) => HookResult
+
+}
+export interface FlowApp {
+  router: { byUrl: RadixRouter<FlowPage['context']>; byName: RadixRouter<FlowPage['context']> }
+  hooks: Hookable<FlowAppHooks>
+  hook: FlowApp['hooks']['hook']
+  callHook: FlowApp['hooks']['callHook']
+  eta: any
+  app: {
+    utils: Record<string, any>
+    plugins: Record<string, any>
+    globals: Record<string, any>
+  }
+  engine: string
+
+  engines: Record<string, (template: string) => string>
+  generate: boolean
+  render: (view: Record<string, string>, data: any) => Promise<string>|void|string
+  provide: (name: string, value: any) => void
+  setUtil: (name: string, value: any) => void
+
+  [key: string]: any
+
+}
+
+export const FlowPluginIndicator = '__flow_plugin';
+export const NuxtPluginIndicator = '__nuxt_plugin';
+
+export interface Plugin<Injections extends Record<string, any> = Record<string, any>> {
+  (flow: FlowApp): Promise<void> | Promise<{ provide?: Injections }> | void | { provide?: Injections }
+  [FlowPluginIndicator]?: true
+}
+interface OptionsApp {
+  runtimeConfig: RuntimeConfig
+}
+
+export function createFlowApp({ runtimeConfig }: OptionsApp): FlowApp {
+  //
+
+  const viewsDir = join(runtimeConfig.app.rootDir, 'views');
+
+  const flowApp: FlowApp = {
+    router: { byUrl: createRouter(), byName: createRouter() },
+    app: {
+      utils: {},
+      globals: {},
+    },
+    eta: {
+      views: viewsDir,
+      plugins: [],
+    },
+    engine: 'eta',
+    engines: { },
+    generate: runtimeConfig.generate,
+  } as FlowApp;
+
+  flowApp.engines.eta = (template: string) => {
+    return `<%~ await includeFile('templates/${template}',it) %>`;
+  };
+  flowApp.hooks = createHooks<FlowAppHooks>();
+  flowApp.hook = flowApp.hooks.hook;
+  flowApp.callHook = flowApp.hooks.callHook;
+
+  flowApp.provide = (name: string, value: any) => {
+    const $name = `$${name}`;
+    defineGetter(flowApp, $name, value);
+    // defineGetter(nuxtApp.vueApp.config.globalProperties, $name, value);
+  };
+  flowApp.setUtil = (name: string, method: any) => {
+    flowApp.app.utils[name] = method;
+  };
+
+  flowApp.hook('eta:plugin', (_plugin) => {
+    flowApp.eta.plugins.push(_plugin);
+  });
+
+  flowApp.provide('config', runtimeConfig);
+
+  return flowApp;
+}
+
+export function defineFlowPlugin<T>(plugin: Plugin<T>) {
+  plugin[FlowPluginIndicator] = true;
+  return plugin;
+}
+
+export function defineNuxtPlugin<T>(plugin: Plugin<T>) {
+  plugin[NuxtPluginIndicator] = true;
+  return plugin;
+}
+
+export async function applyPlugin(flowApp: FlowApp, plugin: Plugin) {
+  if (typeof plugin !== 'function') return;
+  const { provide } = await callWithFlow(flowApp, plugin, [flowApp]) || {};
+  if (provide && typeof provide === 'object') {
+    for (const key in provide)
+      flowApp.provide(key, provide[key]);
+  }
+}
+export async function applyPlugins(flowApp: FlowApp, plugins: Plugin[]) {
+  for (const plugin of plugins)
+    await applyPlugin(flowApp, plugin);
+}
+
+/**
+ * Ensures that the setup function passed in has access to the Nuxt instance via `useNuxt`.
+ *
+ * @param flow A Flow instance
+ * @param setup The function to call
+ */
+export function callWithFlow<T extends(...args: any[]) => any> (flow: FlowApp, setup: T, args?: Parameters<T>) {
+  const fn = () => args ? setup(...args as Parameters<T>) : setup();
+  // TODO: posible error
+  flowAppCtx.set(flow);
+  return flowAppCtx.callAsync<ReturnType<T>>(flow, fn);
+}
+/**
+ * Returns the current Nuxt instance.
+ */
+export function useFlowApp() {
+  const flowAppInstance = flowAppCtx.use();
+  if (!flowAppInstance)
+    throw new Error('flow instance unavailable');
+
+  return flowAppInstance;
+}
+export function useRuntimeConfig(): RuntimeConfig {
+  return useFlowApp().$config;
+}
+
+function defineGetter<K extends string | number | symbol, V>(obj: Record<K, V>, key: K, val: V) {
+  Object.defineProperty(obj, key, { get: () => val });
+}
+
+export async function resolveFiles(path: string, pattern: string | string[]) {
+  const files = await globby(pattern, { cwd: path, followSymbolicLinks: true });
+  return files.filter((file) => !file.includes('copy.ts')).map((p) => resolve(path, p));
+}

package/src/app/index.ts

@@ -0,0 +1,5 @@
+export * from './flow';
+export * from './composables';
+
+// @ts-ignore
+export { useHead } from '#head';