@takeshape/ssg 11.124.6 → 11.125.1

package/dist/generate/generate.js

@@ -4,7 +4,7 @@ import BbPromise from 'bluebird';
 import compose from 'lodash/fp/compose.js';
 import flatten from 'lodash/fp/flatten.js';
 import partition from 'lodash/partition.js';
-import values from 'lodash/values.js';
+import uniqBy from 'lodash/uniqBy.js';
 import { obj as Pumpify } from 'pumpify';
 import compressHtml from "../compress-html.js";
 import { localizeConfig } from "../config.js";
@@ -122,22 +122,31 @@ function renderTemplates(generateContext) {
         const routeContext = await resolveRouteContext(generateContext, route);
         const context = combineContext(config.env, globalContext, route, routeContext);
         const path = joinPath(pathPrefix, route.path);
-        return renderTemplate(path, route.template, context);
+        const page = await renderTemplate(path, route.template, context);
+        return {
+            pages: [page],
+            order: route._routeOrder
+        };
     });
 }
 function renderPaginatedTemplates(generateContext) {
     const render = renderPaginatedTemplate(generateContext, getPaginatedData);
     return async (routes) => {
         const { config, globalContext } = generateContext;
-        const pages = await BbPromise.map(routes, async (route) => {
+        return BbPromise.map(routes, async (route) => {
             const routeContext = await resolveRouteContext(generateContext, route);
-            return render(route, combineContext(config.env, globalContext, route, routeContext));
+            const renderedPages = await render(route, combineContext(config.env, globalContext, route, routeContext));
+            return {
+                pages: renderedPages,
+                order: route._routeOrder
+            };
         });
-        return flatten(pages);
     };
 }
 async function generatePages(config, generateContext) {
-    const [paginatedRoutes, singleRoutes] = partition(values(config.routes), 'paginate');
+    const routeEntries = Object.entries(config.routes);
+    const routesWithOrder = routeEntries.map(([, route], index) => ({ ...route, _routeOrder: index }));
+    const [paginatedRouteConfigs, singleRouteConfigs] = partition(routesWithOrder, 'paginate');
     const renderContext = {
         ...generateContext,
         globalContext: {
@@ -153,9 +162,13 @@ async function generatePages(config, generateContext) {
             locale: config.locale
         }
     };
-    const singlePages = await renderTemplates(renderContext)(singleRoutes);
-    const paginatedPages = await renderPaginatedTemplates(renderContext)(paginatedRoutes);
-    return singlePages.concat(paginatedPages);
+    const singleRoutes = await renderTemplates(renderContext)(singleRouteConfigs);
+    const paginatedRoutes = await renderPaginatedTemplates(renderContext)(paginatedRouteConfigs);
+    const allRoutes = singleRoutes.concat(paginatedRoutes);
+    const sortedRoutes = allRoutes.sort((a, b) => a.order - b.order);
+    const allPages = sortedRoutes.flatMap((route) => route.pages);
+    // First route wins
+    return uniqBy(allPages, 'path');
 }
 function removeListingPageConfig(routeConfig) {
     if (routeConfig.paginate) {
@@ -212,9 +225,12 @@ export async function generateRoute(config, params) {
         config,
         globalContext
     };
-    const pages = await (routeConfig.paginate
-        ? renderPaginatedTemplates(renderContext)([removeListingPageConfig(routeConfig)])
-        : renderTemplates(renderContext)([routeConfig]));
+    const routeWithOrder = { ...routeConfig, _routeOrder: 0 };
+    const routes = await (routeConfig.paginate
+        ? renderPaginatedTemplates(renderContext)([{ ...removeListingPageConfig(routeConfig), _routeOrder: 0 }])
+        : renderTemplates(renderContext)([routeWithOrder]));
+    // Flatten routes to pages since there's only one route
+    const pages = routes.flatMap((route) => route.pages);
     return {
         pages,
         stats

package/dist/types.d.ts

@@ -28,6 +28,10 @@ export type RenderedPage = {
     path: string;
     contents: string | Buffer;
 };
+export type RenderedRoute = {
+    pages: RenderedPage[];
+    order: number;
+};
 export type RenderTemplate = (path: string, template: string, context: TemplateContext) => Promise<RenderedPage>;
 export type RenderTemplateDecorator = (renderTemplate: RenderTemplate) => RenderTemplate;
 export type GraphQLConnectorParams = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/ssg",
-  "version": "11.124.6",
+  "version": "11.125.1",
   "description": "Static Site Generator",
   "homepage": "https://www.takeshape.io",
   "repository": {
@@ -42,10 +42,10 @@
     "pluralize": "8.0.0",
     "pumpify": "2.0.1",
     "resolve": "1.22.8",
-    "@takeshape/routing": "11.124.6",
-    "@takeshape/streams": "11.124.6",
-    "@takeshape/util": "11.124.6",
-    "@takeshape/prism": "11.124.6"
+    "@takeshape/prism": "11.125.1",
+    "@takeshape/streams": "11.125.1",
+    "@takeshape/util": "11.125.1",
+    "@takeshape/routing": "11.125.1"
   },
   "devDependencies": {
     "@types/bluebird": "3.5.33",