@monkeyplus/flow 6.0.13 → 6.0.15

package/modules/netlify-cms/server/lib/composables.mjs

@@ -0,0 +1,14 @@
+import { join } from "node:path";
+export function defineCmsCollection(options) {
+  return (ctx) => {
+    const setupFn = options.setup(ctx);
+    const collectionFn = setupFn(join(options.group, options.dir));
+    return (baseDir, ctx2) => {
+      const collection = collectionFn(baseDir, ctx2);
+      return {
+        ...collection,
+        group: options.group
+      };
+    };
+  };
+}

package/modules/netlify-cms/server/lib/entries.d.ts

@@ -0,0 +1,25 @@
+export declare function entriesFromFiles(repoPath: string, files: {
+    path: string;
+    label?: string;
+}[]): Promise<({
+    data: string;
+    file: {
+        path: string;
+        label: string | undefined;
+        id: any;
+    };
+} | {
+    data: null;
+    file: {
+        path: string;
+        label: string | undefined;
+        id: null;
+    };
+})[]>;
+export declare function readMediaFile(repoPath: string, file: string): Promise<{
+    id: any;
+    content: string;
+    encoding: string;
+    path: string;
+    name: any;
+}>;

package/modules/netlify-cms/server/lib/entries.mjs

@@ -0,0 +1,39 @@
+import crypto from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+function sha256(buffer) {
+  return crypto.createHash("sha256").update(buffer).digest("hex");
+}
+function normalizePath(path2) {
+  return path2.replace(/\\/g, "/");
+}
+export async function entriesFromFiles(repoPath, files) {
+  return Promise.all(
+    files.map(async (file) => {
+      try {
+        const content = await fs.readFile(path.join(repoPath, file.path));
+        return {
+          data: content.toString(),
+          file: { path: normalizePath(file.path), label: file.label, id: sha256(content) }
+        };
+      } catch (e) {
+        return {
+          data: null,
+          file: { path: normalizePath(file.path), label: file.label, id: null }
+        };
+      }
+    })
+  );
+}
+export async function readMediaFile(repoPath, file) {
+  const encoding = "base64";
+  const buffer = await fs.readFile(path.join(repoPath, file));
+  const id = sha256(buffer);
+  return {
+    id,
+    content: buffer.toString(encoding),
+    encoding,
+    path: normalizePath(file),
+    name: path.basename(file)
+  };
+}

package/modules/netlify-cms/server/lib/fs.d.ts

@@ -0,0 +1,5 @@
+export declare function listRepoFiles(repoPath: string, folder: string, extension: string, depth: number): Promise<string[]>;
+export declare function writeFile(filePath: string, content: Buffer | string): Promise<void>;
+export declare function deleteFile(repoPath: string, filePath: string): Promise<void>;
+export declare function move(from: string, to: string): Promise<void>;
+export declare function getUpdateDate(repoPath: string, filePath: string): Promise<Date>;

package/modules/netlify-cms/server/lib/fs.mjs

@@ -0,0 +1,43 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+async function listFiles(dir, extension, depth) {
+  if (depth <= 0)
+    return [];
+  try {
+    const dirents = await fs.readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(
+      dirents.map((dirent) => {
+        const res = path.join(dir, dirent.name);
+        return dirent.isDirectory() ? listFiles(res, extension, depth - 1) : [res].filter((f) => f.endsWith(extension));
+      })
+    );
+    return [].concat(...files);
+  } catch (e) {
+    return [];
+  }
+}
+export async function listRepoFiles(repoPath, folder, extension, depth) {
+  const files = await listFiles(path.join(repoPath, folder), extension, depth);
+  return files.map((f) => f.substr(repoPath.length + 1));
+}
+export async function writeFile(filePath, content) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content);
+}
+export async function deleteFile(repoPath, filePath) {
+  await fs.unlink(path.join(repoPath, filePath)).catch(() => void 0);
+}
+async function moveFile(from, to) {
+  await fs.mkdir(path.dirname(to), { recursive: true });
+  await fs.rename(from, to);
+}
+export async function move(from, to) {
+  await moveFile(from, to);
+  const sourceDir = path.dirname(from);
+  const destDir = path.dirname(to);
+  const allFiles = await listFiles(sourceDir, "", 100);
+  await Promise.all(allFiles.map((file) => moveFile(file, file.replace(sourceDir, destDir))));
+}
+export async function getUpdateDate(repoPath, filePath) {
+  return fs.stat(path.join(repoPath, filePath)).then((stat) => stat.mtime).catch(() => /* @__PURE__ */ new Date());
+}

package/modules/netlify-cms/server/lib/types/collections.d.ts

@@ -0,0 +1,16 @@
+import type { CmsCollection, CmsCollectionFile } from 'netlify-cms-core';
+import type { Cms } from './index';
+export declare namespace Collections {
+    type _Base = Omit<CmsCollection, 'files' | 'folder' | 'fields'>;
+    type Folder = _Base & {
+        folder: string;
+        fields: Cms.Fields[];
+    };
+    type Files = _Base & {
+        files: File[];
+    };
+    type File = Omit<CmsCollectionFile, 'fields'> & {
+        fields: Cms.Fields[];
+        htmlId?: string;
+    };
+}

package/modules/netlify-cms/server/lib/types/helpers.d.ts

@@ -0,0 +1,23 @@
+import type { Collections } from './collections';
+import type { Cms } from './index';
+export type DefineMethod<R> = (parentName: string, ctx: ContextWidget) => R;
+export type DefineMethodExtend<R> = (id: string) => (parentName: string, ctx: ContextWidget) => R;
+export interface ContextWidget {
+    rootDir: string;
+}
+export type DefineFile = Record<string, DefineMethodExtend<Collections.File>>;
+export interface CollectionFileId extends Omit<Collections._Base, 'name'> {
+    files: DefineFile;
+}
+export interface CollectionFolderId extends Omit<Collections.Folder, 'name' | 'folder' | 'fields'> {
+    fields: Model.Fields;
+}
+export declare namespace Model {
+    type Fields = Record<string, (parentName: string, ctx: ContextWidget) => Cms.Fields>;
+}
+export declare namespace Helpers {
+    interface CollectionFiles {
+        (base: CollectionFileId): (baseDir: string) => DefineMethod<Collections.Files>;
+    }
+}
+export type DefineCms = (options: Omit<Cms.Config, 'collections'>, collections: DefineMethod<Collections.Files | Collections.Folder>[]) => (dir: string, ctx: ContextWidget) => Cms.Config;

package/modules/netlify-cms/server/lib/types/index.d.ts

@@ -0,0 +1,23 @@
+import type { Collections } from './collections';
+import type { DefineMethod } from './helpers';
+import type { Widgets } from './widgets';
+export { Collections } from './collections';
+export { ContextWidget, DefineCms } from './helpers';
+export { CollectionFileId, CollectionFolderId, DefineMethod, DefineMethodExtend, Helpers, Model, } from './helpers';
+export { Widgets } from './widgets';
+export declare namespace Cms {
+    type Config = Record<string, any> & {
+        collections: (Collections.Folder | Collections.Files)[];
+    };
+    type Fields = Widgets.Boolean | Widgets.Markdown | Widgets.Code | Widgets.Color | Widgets.DateTime | Widgets.Hidden | Widgets.Map | Widgets.Number | Widgets.Select | Widgets.Text | Widgets.String | Widgets.Relation | Widgets.File | Widgets.Image | Widgets.Object | Widgets.List | Widgets.Date | Widgets.Meta;
+}
+export interface FlowNetlifyCms {
+    config?: Omit<Partial<Cms.Config>, 'collections'>;
+    functions?: {
+        dir: string;
+        proxy?: Record<string, string>;
+    };
+    omitRoutes?: boolean;
+    omitProxy?: boolean;
+    collections?: DefineMethod<Collections.Files | Collections.Folder>[];
+}

package/modules/netlify-cms/server/lib/types/index.mjs

@@ -0,0 +1,11 @@
+export { Collections } from "./collections.mjs";
+export { ContextWidget, DefineCms } from "./helpers.mjs";
+export {
+  CollectionFileId,
+  CollectionFolderId,
+  DefineMethod,
+  DefineMethodExtend,
+  Helpers,
+  Model
+} from "./helpers.mjs";
+export { Widgets } from "./widgets.mjs";

package/modules/netlify-cms/server/lib/types/widgets.d.ts

@@ -0,0 +1,39 @@
+import type { CmsFieldBase, CmsFieldBoolean, CmsFieldCode, CmsFieldColor, CmsFieldDateTime, CmsFieldFileOrImage, CmsFieldHidden, CmsFieldList, CmsFieldMap, CmsFieldMarkdown, CmsFieldMeta, CmsFieldNumber, CmsFieldObject, CmsFieldRelation, CmsFieldSelect, CmsFieldStringOrText } from 'netlify-cms-core';
+import type { Cms } from './index';
+interface CmsFieldExtra {
+    extraOptions?: Record<string, any>;
+    htmlId?: string;
+}
+export declare namespace Widgets {
+    type Boolean = CmsFieldExtra & CmsFieldBase & CmsFieldBoolean;
+    type Markdown = CmsFieldExtra & CmsFieldBase & CmsFieldMarkdown;
+    type Code = CmsFieldExtra & CmsFieldBase & CmsFieldCode;
+    type Color = CmsFieldExtra & CmsFieldBase & CmsFieldColor;
+    type DateTime = CmsFieldExtra & CmsFieldBase & CmsFieldDateTime;
+    type Hidden = CmsFieldExtra & CmsFieldBase & CmsFieldHidden;
+    type Map = CmsFieldExtra & CmsFieldBase & CmsFieldMap;
+    type Number = CmsFieldExtra & CmsFieldBase & CmsFieldNumber;
+    type Select = CmsFieldExtra & CmsFieldBase & CmsFieldSelect;
+    type Text = CmsFieldExtra & CmsFieldBase & CmsFieldStringOrText;
+    type String = CmsFieldExtra & CmsFieldBase & CmsFieldStringOrText;
+    type Relation = CmsFieldExtra & CmsFieldBase & CmsFieldRelation;
+    type File = CmsFieldExtra & CmsFieldBase & CmsFieldFileOrImage;
+    type Image = CmsFieldExtra & CmsFieldBase & CmsFieldFileOrImage;
+    type Meta = CmsFieldExtra & CmsFieldBase & CmsFieldMeta & {
+        options?: Record<string, unknown>;
+    };
+    type Object = CmsFieldExtra & CmsFieldBase & Omit<CmsFieldObject, 'fields'> & {
+        fields?: Cms.Fields[];
+    };
+    type List = CmsFieldExtra & CmsFieldBase & Omit<CmsFieldList, 'fields' | 'field'> & {
+        field?: Cms.Fields;
+        fields?: Cms.Fields[];
+    };
+    type Date = CmsFieldExtra & CmsFieldBase & {
+        widget: 'date';
+        format?: string;
+        date_format?: boolean | string;
+        time_format?: boolean | string;
+    };
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "6.0.13",
+  "version": "6.0.15",
   "description": "@monkeyplus/flow package-first runtime with Vite, Nitro, Vue and a workspace playground.",
   "license": "MIT",
   "publishConfig": {

package/server/lib/handler.mjs

@@ -1,7 +1,7 @@
-import clientAssets from "../../src/main.mjs?assets=client";
 import bundleAssets from "virtual:flow/client-page-assets";
-import { renderDocument } from "./render.mjs";
+import clientAssets from "../../src/main.mjs?assets=client";
 import { resolvePage, resolvePageByName } from "./pages.mjs";
+import { renderDocument } from "./render.mjs";
 function mergeClientAssets(baseAssets, pageAssets) {
   const css = [...baseAssets.css || [], ...pageAssets?.css || []];
   const js = [...baseAssets.js || [], ...pageAssets?.js || []];

package/server/renderer.mjs

@@ -36,6 +36,10 @@ async function resolvePrerenderFetchHandler() {
   return await prerenderFetchHandlerPromise;
 }
 export default async function renderPage(input) {
+  const nitroApp = globalThis.__nitro__;
+  if (nitroApp && nitroApp.localFetch) {
+    globalThis.$fetch = nitroApp.localFetch;
+  }
   const viteEnvs = globalThis.__nitro_vite_envs__;
   const request = resolveRequest(input);
   const viteEnv = viteEnvs?.ssr;

package/src/main.d.ts

@@ -1 +1 @@
-export {};
+import 'virtual:flow/server-styles';

package/src/main.mjs

@@ -1,5 +1,6 @@
-import { hydrateIslands } from "./runtime/islands.mjs";
 import bundles from "virtual:flow/client-pages";
+import { hydrateIslands } from "./runtime/islands.mjs";
+import "virtual:flow/server-styles";
 function readBoot() {
   const element = document.getElementById("flow-boot");
   if (!element?.textContent) {

package/src/public/nitro.mjs

@@ -64,10 +64,12 @@ export function createFlowNitroConfig(options = {}) {
     plugins: flowModules.nitro.plugins,
     noExternals: [...configuredNoExternals, flowPackagePattern],
     handlers: flowModules.nitro.handlers,
+    storage: flowModules.nitro.storage,
     routeRules: {
       "/api/**": { cors: true },
       ...flowModules.nitro.routeRules
     },
+    imports: flowModules.nitro.imports,
     runtimeConfig: {
       app: {
         name: "Flow Next",

package/src/public/query-content.d.ts

@@ -1,7 +1,15 @@
 import type { ContentEntry, ContentTreeNode } from '../../modules/content/query.ts';
 export interface QueryContentBuilder {
+    where: (field: string, operator: string, value?: unknown) => QueryContentBuilder;
+    order: (field: string, direction: 'ASC' | 'DESC' | 'asc' | 'desc') => QueryContentBuilder;
+    skip: (amount: number) => QueryContentBuilder;
+    limit: (amount: number) => QueryContentBuilder;
+    select: (...fields: string[]) => QueryContentBuilder;
     find: () => Promise<ContentEntry[]>;
     findOne: () => Promise<ContentEntry | null>;
+    all: () => Promise<ContentEntry[]>;
+    first: () => Promise<ContentEntry | null>;
+    surround: (targetPath: string) => Promise<[ContentEntry | null, ContentEntry | null]>;
     tree: () => Promise<ContentTreeNode[]>;
 }
 export declare function queryContent(path?: string): QueryContentBuilder;

package/src/public/query-content.mjs

@@ -27,6 +27,7 @@ function withQuery(url, params) {
   if (!params || Object.keys(params).length === 0) {
     return url;
   }
+  const isAbsolute = url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//");
   const origin = typeof window !== "undefined" ? window.location.origin : "http://localhost:3000";
   const target = new URL(url, origin);
   Object.entries(params).forEach(([key, value]) => {
@@ -35,7 +36,7 @@ function withQuery(url, params) {
     }
     target.searchParams.set(key, String(value));
   });
-  return target.toString();
+  return isAbsolute ? target.toString() : target.pathname + target.search;
 }
 async function getRuntimeConfig() {
   if (typeof window !== "undefined") {
@@ -65,44 +66,46 @@ async function resolveContentApiBase() {
   const runtimeConfig = await getRuntimeConfig();
   return runtimeConfig?.flow?.content?.apiBase || runtimeConfig?.public?.flow?.content?.apiBase || defaultContentConfig.apiBase;
 }
-async function resolveAbsoluteContentApiBase() {
-  const runtimeConfig = await getRuntimeConfig();
+async function fetchContent(route, queryParams) {
   const apiBase = await resolveContentApiBase();
-  if (typeof window !== "undefined") {
-    return apiBase;
+  const query = { ...queryParams };
+  if (query.path === "/") {
+    delete query.path;
   }
-  if (runtimeConfig?.flow?.siteUrl) {
-    return joinUrl(runtimeConfig.flow.siteUrl, apiBase);
+  for (const key of Object.keys(query)) {
+    if (query[key] === void 0 || query[key] === null) {
+      delete query[key];
+    }
   }
-  return joinUrl("http://localhost:3000", apiBase);
-}
-async function fetchContent(route, path) {
-  const apiBase = await resolveContentApiBase();
-  const query = path && path !== "/" ? { path } : void 0;
   const localFetch = getGlobalFetch();
-  const nitroFetch = await getNitroFetch();
-  if (typeof window === "undefined" && localFetch) {
-    console.debug(`[Flow Content] Fetching content from ${joinUrl(apiBase, route)} using global fetch`);
-    return await localFetch(joinUrl(apiBase, route), {
-      headers: {
-        accept: "application/json"
-      },
-      query
-    });
-  }
-  if (typeof window === "undefined" && nitroFetch) {
-    console.debug(`[Flow Content] Fetching content from ${joinUrl(apiBase, route)} using Nitro fetch`);
-    return await nitroFetch(joinUrl(apiBase, route), {
-      headers: {
-        accept: "application/json"
-      },
-      query
-    });
+  const relativeTarget = withQuery(joinUrl(apiBase, route), query);
+  if (typeof window === "undefined") {
+    try {
+      if (import.meta.env?.SSR || process.server) {
+        const { findContentEntries, buildContentTree, findContentTree, readContentEntries } = await import("../../modules/content/query.js");
+        let entries = await readContentEntries();
+        const isTreeRequest = route.endsWith("/tree") || query.tree === true || query.tree === "true" || query.tree === "1";
+        if (isTreeRequest) {
+          const tree = buildContentTree(entries);
+          return findContentTree(tree, query.path);
+        }
+        if (query.path) {
+          entries = findContentEntries(entries, query.path);
+        }
+        if (query.where) {
+          try {
+            const whereConditions = JSON.parse(query.where);
+          } catch {
+          }
+        }
+        return entries;
+      }
+    } catch (e) {
+    }
   }
-  const absoluteBase = await resolveAbsoluteContentApiBase();
-  const target = withQuery(joinUrl(absoluteBase, route), query);
-  console.debug(`[Flow Content] Fetching content from ${target}`);
-  const response = await fetch(target, {
+  const fetchFn = typeof window === "undefined" ? localFetch || fetch : fetch;
+  const targetToFetch = typeof window === "undefined" && localFetch ? relativeTarget : relativeTarget;
+  const response = await fetchFn(targetToFetch, {
     headers: {
       accept: "application/json"
     }
@@ -115,16 +118,79 @@ async function fetchContent(route, path) {
 }
 export function queryContent(path = "") {
   const normalizedPath = normalizeQueryPath(path);
-  return {
+  const queryObj = {
+    path: normalizedPath,
+    where: [],
+    order: [],
+    skip: 0,
+    limit: 0,
+    select: []
+  };
+  const builder = {
+    where(field, operator, value) {
+      if (value === void 0) {
+        value = operator;
+        operator = "=";
+      }
+      queryObj.where.push({ field, operator, value });
+      return this;
+    },
+    order(field, direction = "ASC") {
+      queryObj.order.push({ field, direction });
+      return this;
+    },
+    skip(amount) {
+      queryObj.skip = amount;
+      return this;
+    },
+    limit(amount) {
+      queryObj.limit = amount;
+      return this;
+    },
+    select(...fields) {
+      queryObj.select.push(...fields);
+      return this;
+    },
     async find() {
-      return await fetchContent("query", normalizedPath);
+      const q = { path: queryObj.path };
+      if (queryObj.where.length)
+        q.where = JSON.stringify(queryObj.where);
+      if (queryObj.order.length)
+        q.order = JSON.stringify(queryObj.order);
+      if (queryObj.skip > 0)
+        q.skip = String(queryObj.skip);
+      if (queryObj.limit > 0)
+        q.limit = String(queryObj.limit);
+      if (queryObj.select.length)
+        q.select = queryObj.select.join(",");
+      return await fetchContent("query", q);
     },
     async findOne() {
       const entries = await this.find();
       return entries[0] || null;
     },
+    async all() {
+      return await this.find();
+    },
+    async first() {
+      this.limit(1);
+      return await this.findOne();
+    },
+    async surround(targetPath) {
+      const entries = await this.find();
+      const index = entries.findIndex((e) => e.path === targetPath);
+      if (index === -1) {
+        return [null, null];
+      }
+      return [
+        index > 0 ? entries[index - 1] : null,
+        index < entries.length - 1 ? entries[index + 1] : null
+      ];
+    },
     async tree() {
-      return await fetchContent("tree", normalizedPath);
+      const q = { path: queryObj.path };
+      return await fetchContent("tree", q);
     }
   };
+  return builder;
 }

package/src/public/vite.mjs

@@ -17,6 +17,7 @@ import {
   createVirtualLayoutContextsModule,
   createVirtualLayoutsModule,
   createVirtualPagesModule,
+  createVirtualServerStylesModule,
   createVirtualTemplatesModule
 } from "../runtime/virtual-pages.mjs";
 const flowRestartPatterns = [
@@ -55,6 +56,9 @@ function getVirtualModuleIdsForPath(projectPath) {
   if (projectPath === "flow.config.ts" || projectPath.startsWith("pages/")) {
     ids.add("virtual:flow/pages");
   }
+  if (projectPath.startsWith("views/")) {
+    ids.add("virtual:flow/server-styles");
+  }
   if (projectPath.startsWith("views/templates/")) {
     ids.add("virtual:flow/templates");
   }
@@ -141,7 +145,7 @@ function createFlowHotReload(projectRoot, extraWatchPaths = []) {
       });
     }, 0);
   }
-  async function handleServerChange(server, filePath, event) {
+  async function handleServerChange(server, filePath, event, hmrModules) {
     const projectPath = toProjectPath(filePath);
     invalidateFileModules(server, filePath, event);
     invalidateVirtualModules(server, projectPath);
@@ -153,11 +157,21 @@ function createFlowHotReload(projectRoot, extraWatchPaths = []) {
     if (!shouldReload) {
       return false;
     }
-    server.ws.send({ type: "full-reload", path: "*" });
+    if (event === "change" && projectPath.endsWith(".vue") && hmrModules) {
+      const validModules = hmrModules.filter((m) => m && m.id);
+      const isStyleOnly = validModules.length > 0 && validModules.every((m) => m.id.includes("type=style"));
+      if (isStyleOnly) {
+        return false;
+      }
+    }
+    setTimeout(() => {
+      server.ws.send({ type: "full-reload", path: "*" });
+    }, 50);
     return true;
   }
   return {
     name: "flow:hot-reload",
+    enforce: "post",
     configureServer(server) {
       if (extraWatchPaths.length) {
         server.watcher.add(extraWatchPaths);
@@ -170,9 +184,7 @@ function createFlowHotReload(projectRoot, extraWatchPaths = []) {
       });
     },
     async handleHotUpdate(ctx) {
-      if (await handleServerChange(ctx.server, ctx.file, "change")) {
-        return [];
-      }
+      await handleServerChange(ctx.server, ctx.file, "change", ctx.modules);
     }
   };
 }
@@ -184,7 +196,8 @@ function createFlowVirtualServerModules(projectRoot, flowConfig) {
     ["virtual:flow/templates", () => createVirtualTemplatesModule(projectRoot)],
     ["virtual:flow/layouts", () => createVirtualLayoutsModule(projectRoot)],
     ["virtual:flow/layout-contexts", () => createVirtualLayoutContextsModule(projectRoot)],
-    ["virtual:flow/bases", () => createVirtualBaseTemplatesModule(projectRoot)]
+    ["virtual:flow/bases", () => createVirtualBaseTemplatesModule(projectRoot)],
+    ["virtual:flow/server-styles", () => createVirtualServerStylesModule(projectRoot)]
   ]);
   return {
     name: "flow:server-virtuals",

package/src/runtime/config.d.ts

@@ -71,6 +71,13 @@ export interface FlowModuleNitroConfig extends Record<string, unknown> {
     routeRules: Record<string, Record<string, unknown>>;
     runtimeConfig: Record<string, unknown>;
     virtual: Record<string, string | (() => string | Promise<string>)>;
+    imports?: {
+        imports: Array<{
+            name: string;
+            from: string;
+            as?: string;
+        }>;
+    };
 }
 export interface FlowModuleViteConfig extends Record<string, unknown> {
     plugins: unknown[];

package/src/runtime/modules.mjs

@@ -7,7 +7,8 @@ function createNitroConfig() {
     handlers: [],
     routeRules: {},
     runtimeConfig: {},
-    virtual: {}
+    virtual: {},
+    imports: { imports: [] }
   };
 }
 function createViteConfig() {

package/src/runtime/nitro-plugin.d.ts

@@ -0,0 +1 @@
+export default function (nitroApp: any): void;

package/src/runtime/nitro-plugin.mjs

@@ -0,0 +1,5 @@
+export default function(nitroApp) {
+  if (!globalThis.$fetch && nitroApp) {
+    globalThis.$fetch = nitroApp.fetch;
+  }
+}

package/src/runtime/virtual-pages.d.ts

@@ -7,3 +7,4 @@ export declare function createVirtualBaseTemplatesModule(projectRoot: string): s
 export declare function createVirtualIslandsModule(projectRoot: string): string;
 export declare function createVirtualClientPagesModule(projectRoot: string): string;
 export declare function createVirtualClientPageAssetsModule(projectRoot: string): string;
+export declare function createVirtualServerStylesModule(projectRoot: string): string;

package/src/runtime/virtual-pages.mjs

@@ -1,3 +1,4 @@
+import { parse } from "vue/compiler-sfc";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, extname, resolve } from "node:path";
 function collectFiles(rootDir, extensions, currentDir = rootDir) {
@@ -170,3 +171,20 @@ export function createVirtualClientPageAssetsModule(projectRoot) {
     ""
   ].join("\n");
 }
+export function createVirtualServerStylesModule(projectRoot) {
+  const viewsDir = resolve(projectRoot, "views");
+  const files = existsSync(viewsDir) ? collectFiles(viewsDir, [".vue"]) : [];
+  const imports = files.flatMap((filePath) => {
+    const code = readFileSync(filePath, "utf8");
+    const { descriptor } = parse(code);
+    return descriptor.styles.map((style, i) => {
+      return `import "${toAbsoluteImport(filePath)}?vue&type=style&index=${i}&lang.${style.lang || "css"}";`;
+    });
+  });
+  return [
+    ...imports,
+    "",
+    "export default {};",
+    ""
+  ].join("\n");
+}