@monkeyplus/flow 6.0.12 → 6.0.14

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.12",
+  "version": "6.0.14",
   "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/lib/pages.mjs

@@ -130,6 +130,26 @@ function replacePath(pattern, url) {
 function combineName(name, dynamicName) {
   return `${name.replace(/\/*$/, "")}/${dynamicName.replace(/^\/*/, "")}`;
 }
+function resolveUrlTarget(namePage, explicitDynamicName) {
+  if (explicitDynamicName || !namePage.includes("/")) {
+    return {
+      namePage,
+      dynamicName: explicitDynamicName
+    };
+  }
+  const match = pageDefinitions.filter((candidate) => candidate.name && namePage.startsWith(`${candidate.name}/`)).sort((left, right) => right.name.length - left.name.length)[0];
+  if (!match) {
+    return {
+      namePage,
+      dynamicName: explicitDynamicName
+    };
+  }
+  const dynamicName = namePage.slice(match.name.length + 1);
+  return {
+    namePage: match.name,
+    dynamicName: dynamicName || explicitDynamicName
+  };
+}
 function getEnabledLocaleCodes() {
   const runtimeConfig = getFlowRuntimeConfig();
   return runtimeConfig.flow?.locale?.locales || [];
@@ -163,8 +183,9 @@ export async function getUrl(namePage, localeCode, options = {}) {
   const enabledLocales = getEnabledLocaleCodes();
   const targetLocale = localeCode || enabledLocales[0];
   const runtimeConfig = getFlowRuntimeConfig();
+  const target = resolveUrlTarget(namePage, options.dynamicName);
   for (const definition of pageDefinitions) {
-    if (definition.name !== namePage) {
+    if (definition.name !== target.namePage) {
       continue;
     }
     const localeEntries = targetLocale ? [targetLocale] : Object.keys(definition.locales);
@@ -180,11 +201,11 @@ export async function getUrl(namePage, localeCode, options = {}) {
       if (options.params) {
         return replacePath(localizedRoute, options.params);
       }
-      if (localePage.dynamic && options.dynamicName) {
+      if (localePage.dynamic && target.dynamicName) {
         const locale = createLocale(code);
         const ctx = createContext(definition, locale, localePage, toPublicRoute(runtimeConfig.flow, code, localePage.url), {});
         const entries = await getDynamicEntries(definition, code, ctx);
-        const entry = entries.find((candidate) => candidate.name === options.dynamicName);
+        const entry = entries.find((candidate) => candidate.name === target.dynamicName);
         if (!entry) {
           return void 0;
         }

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/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/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/page-discovery.mjs

@@ -53,6 +53,26 @@ function replacePath(pattern, url) {
 function combineName(name, dynamicName) {
   return `${name.replace(/\/*$/, "")}/${dynamicName.replace(/^\/*/, "")}`;
 }
+function resolveUrlTarget(definitions, namePage, explicitDynamicName) {
+  if (explicitDynamicName || !namePage.includes("/")) {
+    return {
+      namePage,
+      dynamicName: explicitDynamicName
+    };
+  }
+  const match = definitions.filter((candidate) => candidate.name && namePage.startsWith(`${candidate.name}/`)).sort((left, right) => right.name.length - left.name.length)[0];
+  if (!match) {
+    return {
+      namePage,
+      dynamicName: explicitDynamicName
+    };
+  }
+  const dynamicName = namePage.slice(match.name.length + 1);
+  return {
+    namePage: match.name,
+    dynamicName: dynamicName || explicitDynamicName
+  };
+}
 function createContext(definitions, flowConfig, definition, locale, localePage, pathname, params, dynamic) {
   return {
     dynamic,
@@ -111,7 +131,8 @@ export async function loadPageDefinitions(projectRoot, flowConfig) {
   return pages;
 }
 export async function getUrlFromDefinitions(definitions, flowConfig, namePage, localeCode = flowConfig.locale.locales[0], options = {}) {
-  const definition = definitions.find((candidate) => candidate.name === namePage);
+  const target = resolveUrlTarget(definitions, namePage, options.dynamicName);
+  const definition = definitions.find((candidate) => candidate.name === target.namePage);
   if (!definition) {
     return void 0;
   }
@@ -126,9 +147,9 @@ export async function getUrlFromDefinitions(definitions, flowConfig, namePage, l
   if (options.params) {
     return replacePath(localizedRoute, options.params);
   }
-  if (localePage.dynamic && options.dynamicName) {
+  if (localePage.dynamic && target.dynamicName) {
     const entries = await getDynamicEntries(definitions, flowConfig, definition, localeCode, localePage);
-    const entry = entries.find((candidate) => candidate.name === options.dynamicName);
+    const entry = entries.find((candidate) => candidate.name === target.dynamicName);
     if (!entry) {
       return void 0;
     }