@monkeyplus/flow 5.0.0-rc.199 → 5.0.0-rc.2

package/src/pages/runtime/plugin.ts

@@ -0,0 +1,65 @@
+
+import { joinURL } from 'ufo';
+import type { FlowPage } from '@monkeyplus/flow-schema';
+import { definePage } from './helpers';
+import { defineFlowPlugin, useRuntimeConfig } from '#app';
+// @ts-ignore
+import pages from '#pages';
+
+export default defineFlowPlugin(async(flow) => {
+  const { app } = useRuntimeConfig();
+  const allPages: FlowPage['context'] [] = [];
+
+  Object.entries(pages).forEach(([name, page]) => {
+    const { getPages } = definePage({
+      name,
+      // @ts-expect-error
+      ...page,
+    });
+    const _pages = getPages(app.locale.location!, app.locale.language!);
+    _pages.forEach((page) => {
+      flow.router.byUrl.insert(page.url, page.context);
+      flow.router.byName.insert(page.name, page.context);
+      allPages.push(page.context);
+    });
+  });
+
+  function getUrl(namePage: string, localeCode?: string): string {
+    const code: string = 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(withLocale = false) {
+    const urls: (string|{ url: string; locale: string; name: string })[] = [];
+    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),
+        });
+        dPages.forEach((dPage) => {
+          const _path = joinURL(page.path.replace('/**', ''), dPage.url);
+          urls.push(withLocale ? { url: _path, locale: page.locale.code, name: joinURL(page.name, dPage.name) } : _path);
+        });
+      }
+    }
+    return urls.sort();
+  }
+  flow.setUtil('getUrl', getUrl);
+  flow.setUtil('getUrls', getUrls);
+  flow.setUtil('getPages', () => allPages);
+
+  return {
+    provide: {
+      pages: { allPages },
+    },
+  };
+});

package/src/pages/templates.ts

@@ -0,0 +1,20 @@
+import { genDynamicImport } from 'knitwork';
+import { isAbsolute, relative } from 'pathe';
+import { pascalCase } from 'scule';
+import type { Pages } from './utils';
+export interface PagesTemplateOptions {
+  buildDir?: string
+  pages: Pages[]
+}
+// TODO: include localeDefault
+export const pagesTypeTemplate = {
+  filename: 'pages.d.ts',
+  getContents: ({ options }: { options: PagesTemplateOptions }) => `// Generated by pages discovery
+export {}
+declare global {
+
+${options.pages.map((c) => `export type ${pascalCase(c.name)}Context=Awaited<ReturnType<typeof ${genDynamicImport(isAbsolute(c.file) ? relative(options.buildDir, c.file) : c.file, { wrapper: false })}['pages']['locales']['es-ec']['context']>>`).join('\n')}
+}
+export const pagesNames: string[]
+`.replaceAll('.ts', ''),
+};

package/src/pages/utils.ts

@@ -0,0 +1,49 @@
+
+import { resolveFilesFlow, useNuxt } from '@monkeyplus/flow-kit';
+import { extname, relative, resolve } from 'pathe';
+import escapeRE from 'escape-string-regexp';
+import { camelCase } from 'scule';
+import { genImport } from 'knitwork';
+
+// import {} from
+
+export interface Pages{ file: string; name: string }
+export async function resolvePagesRoutes(): Promise<Pages[]> {
+  const nuxt = useNuxt();
+
+  const pagesDirs = [...new Set(nuxt.options._layers.map(
+    (layer) => resolve(layer.config.srcDir, layer.config.dir?.pages || 'pages'),
+  ))];
+
+  const allRoutes: Pages[] = (await Promise.all(
+    pagesDirs.map(async(dir) => {
+      const files = await resolveFilesFlow(dir, `**/*{${nuxt.options.extensions.join(',')}}`);
+
+      // Sort to make sure parent are listed first
+
+      files.sort();
+      return files.map((file) => {
+        const segments = relative(dir, file).replace(new RegExp(`${escapeRE(extname(file))}$`), '')
+          .split('/').join('_');
+
+        return {
+          file,
+          name: camelCase(segments),
+        };
+      });
+    }),
+  )).flat();
+
+  return allRoutes;
+
+  // return uniqueBy(allRoutes, 'path');
+}
+
+export function normalizePages(pages: Pages[]) {
+  const imports = pages.map((page) => genImport(page.file, [{ name: 'pages', as: page.name }])).join('\n');
+  return {
+    imports,
+    exports: pages.reduce((acc, curr) => `${curr.name || ''},${acc}`, ''),
+
+  };
+}

package/src/vite-client/module.ts

@@ -0,0 +1,84 @@
+import { addPlugin, addTemplate, defineFlowModule } from '@monkeyplus/flow-kit';
+import type { FlowModule } from '@monkeyplus/flow-schema';
+import { resolve } from 'pathe';
+// import { genImport } from 'knitwork';
+import fse from 'fs-extra';
+import logger from 'consola';
+import { joinURL } from 'ufo';
+import { builClient, createClient } from '../core/vite/client';
+import { distDir } from '../dirs';
+
+interface OptionsViteClient{
+  route: string
+  dir: string
+}
+export default defineFlowModule<OptionsViteClient>({
+
+  meta: {
+    name: 'vite-client',
+    configKey: 'bundle',
+  },
+  defaults: {
+    route: '/_vite/',
+    dir: '/client/pages',
+  },
+  async setup(_options, flow) {
+    const runtimeDir = resolve(distDir, 'vite-client/runtime');
+    flow.options.alias['#viteManifest'] = resolve(flow.options.buildDir, 'viteManifest.mjs');
+    let vite: any;
+    if (flow.options.dev) {
+      flow.hook('nitro:init', async(nitro) => {
+        vite = await createClient(flow);
+        // return vite.middlewares;
+        nitro.options.devHandlers.push({
+          handler: vite.middlewares,
+          route: _options.route,
+        });
+      });
+      // addDevServerHandler({
+      //   route: _options.route,
+      //   handler: async(req, res) => {
+      //     return await vite.middlewares(req, res);
+      //   },
+      // });
+
+      addTemplate({
+        filename: 'viteManifest.mjs',
+        async getContents() {
+          return ['export default {',
+            `head:()=>'<script type="module" src="${joinURL('/', _options.route, '/@vite/client')}"></script>'`,
+            ',',
+            // eslint-disable-next-line no-template-curly-in-string
+            `body: (bundle)=>\`<script type="module" src="${joinURL('/', _options.route, _options.dir)}/\${bundle}.ts"></script>\``,
+            '}',
+          ].join('\n');
+        },
+      });
+    }
+    else {
+      flow.hook('modules:done', async() => {
+        const start = Date.now();
+        logger.info('Building client...');
+        await builClient(flow);
+
+        const file = resolve(flow.options.rootDir, '.vite/manifest.json');
+        const manifest = await fse.readFile(file, 'utf8');
+        logger.success(`Client build in ${Date.now() - start}ms`);
+
+        addTemplate({
+          filename: 'viteManifest.mjs',
+          async getContents() {
+            return ['export default ()=>(', manifest, ')',
+            ].join('\n');
+          },
+        });
+        // Manifest json
+      });
+      flow.hook('generate:before', async() => {
+        const files = resolve(flow.options.rootDir, '.vite/scripts');
+        await fse.copy(files, resolve(flow.options.generate.dir, 'assets'));
+      });
+    }
+    addPlugin({ src: resolve(runtimeDir, 'plugin') });
+  },
+}) as FlowModule<OptionsViteClient>;

package/src/vite-client/runtime/injectManifest.ts

@@ -0,0 +1,188 @@
+import { joinURL } from 'ufo';
+export 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 const generateBundle = (config: any, bundle: Manifest, _id: string) => {
+  const analyzedChunk: Map<ManifestChunk, number> = new Map();
+
+  const getImportedChunks = (
+    chunk: ManifestChunk,
+    seen: Set<string> = new Set(),
+  ): ManifestChunk[] => {
+    const chunks: ManifestChunk[] = [];
+    chunk.imports?.forEach((file) => {
+      const importee = bundle[file];
+      if (file.startsWith('_') && !seen.has(file)) {
+        seen.add(file);
+
+        // post-order traversal
+        chunks.push(...getImportedChunks(importee, seen));
+        chunks.push(importee);
+      }
+    });
+    // TODO: evaluate if is nesesary
+    // chunk.dynamicImports?.forEach((file) => {
+    //   const importee = bundle[file];
+    //   if (!seen.has(file)) {
+    //     seen.add(file);
+    //     // post-order traversal
+    //     chunks.push(...getImportedChunks(importee, seen));
+    //     chunks.push(importee);
+    //   }
+    // });
+    return chunks;
+  };
+  const toScriptTag = (
+    chunk: ManifestChunk,
+    publicBase: string,
+    isAsync: boolean,
+  ): HtmlTagDescriptor => ({
+    tag: 'script',
+    attrs: {
+      ...(isAsync ? { async: true } : {}),
+      type: 'module',
+      crossorigin: true,
+      src: toPublicPath(chunk.file, publicBase),
+    },
+  });
+
+  const toPreloadTag = (
+    chunk: ManifestChunk,
+    publicBase: string,
+  ): HtmlTagDescriptor => ({
+    tag: 'link',
+    attrs: {
+      rel: 'modulepreload',
+      crossorigin: true,
+      href: toPublicPath(chunk.file, publicBase),
+    },
+  });
+
+  const getCssTagsForChunk = (
+    chunk: ManifestChunk,
+    publicBase: string,
+    seen: Set<string> = new Set(),
+  ): HtmlTagDescriptor[] => {
+    const tags: HtmlTagDescriptor[] = [];
+    if (!analyzedChunk.has(chunk)) {
+      analyzedChunk.set(chunk, 1);
+      chunk.imports?.forEach((file) => {
+        const importee = bundle[file];
+        if (file.startsWith('_'))
+          tags.push(...getCssTagsForChunk(importee, publicBase, seen));
+      });
+    }
+
+    chunk.css?.forEach((file) => {
+      if (!seen.has(file)) {
+        seen.add(file);
+        tags.push({
+          tag: 'link',
+          attrs: {
+            rel: 'stylesheet',
+            href: toPublicPath(file, publicBase),
+          },
+        });
+      }
+    });
+
+    return tags;
+  };
+
+  // const relativeUrlPath = path.posix.relative(config.root, id);
+  const publicBase = config.baseURL || '/'; // getPublicBase(relativeUrlPath, config);
+
+  const isAsync = false;// isAsyncScriptMap.get(config)!.get(id)!;
+
+  // const result = html;
+  const chunk = Object.values(bundle).find(
+    (chunk) =>
+      chunk.isEntry && chunk.src === _id,
+  );
+
+  if (chunk) {
+    // when not inlined, inject <script> for entry and modulepreload its dependencies
+    // when inlined, discard entry chunk and inject <script> for everything in post-order
+    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: '' };
+    // result = injectToHead(result, assetTags);
+  }
+};
+
+export const externalRE = /^(https?:)?\/\//;
+export const isExternalUrl = (url: string): boolean => externalRE.test(url);
+
+function toPublicPath(filename: string, publicBase: string) {
+  return isExternalUrl(filename) ? filename : joinURL(publicBase, filename.replace('scripts', 'assets'));
+}
+
+const unaryTags = new Set(['link', 'meta', 'base']);
+
+function serializeTag(
+  { tag, attrs, children }: HtmlTagDescriptor,
+  indent = '',
+): string {
+  if (unaryTags.has(tag)) {
+    return `<${tag}${serializeAttrs(attrs)}>`;
+  }
+  else {
+    return `<${tag}${serializeAttrs(attrs)}>${serializeTags(
+      children,
+      incrementIndent(indent),
+    )}</${tag}>`;
+  }
+}
+
+function serializeTags(
+  tags: HtmlTagDescriptor['children'],
+  indent = '',
+): string {
+  if (typeof tags === 'string')
+    return tags;
+
+  else if (tags && tags.length)
+    return tags.map((tag) => `${indent}${serializeTag(tag, indent)}\n`).join('');
+
+  return '';
+}
+
+function serializeAttrs(attrs: HtmlTagDescriptor['attrs']): string {
+  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] === '\t' ? '\t' : '  '}`;
+}

package/src/vite-client/runtime/plugin.ts

@@ -0,0 +1,33 @@
+
+import logger from 'consola';
+import { generateBundle } from './injectManifest';
+import { defineFlowPlugin } from '#app';
+// @ts-ignore
+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/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));