Add pages config that allows extracting language from path instead of generating pages automatically

Signed-off-by: Dmitriy Nevzorov <jimmy.lugat@gmail.com>

Author: jimmyn

.github/workflows/publish.yml

@@ -33,6 +33,10 @@
     "gatsby-node.js",
     "gatsby-ssr.js"
   ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "scripts": {
     "build:ts": "babel src --out-dir dist --extensions .ts,.tsx",
     "build:defs": "tsc --declaration --outDir dist --emitDeclarationOnly",
@@ -47,19 +51,22 @@
     "@types/react": "^16.9.43",
     "@types/react-helmet": "^6.0.0",
     "babel-preset-gatsby-package": "^0.4.6",
-    "gatsby": "^2.24.3",
+    "gatsby": "^2.24.8",
     "husky": "^4.2.5",
     "i18next": "^19.6.2",
     "prettier": "^2.0.5",
     "pretty-quick": "^2.0.1",
+    "react": "^16.13.1",
+    "react-dom": "^16.13.1",
     "react-i18next": "^11.7.0",
     "release-it": "^13.6.5",
     "typescript": "^3.9.7"
   },
   "dependencies": {
     "bluebird": "^3.7.2",
     "browser-lang": "^0.1.0",
-    "glob": "^7.1.6"
+    "glob": "^7.1.6",
+    "path-to-regexp": "^6.1.0"
   },
   "peerDependencies": {
     "gatsby": "^2.2.0",
@@ -84,7 +91,7 @@
       "release": true
     },
     "npm": {
-      "publish": false
+      "publish": true
     },
     "hooks": {
       "before:init": [

package.json

@@ -3,7 +3,8 @@ import {CreatePageArgs, Page} from 'gatsby';
 import BP from 'bluebird';
 import fs from 'fs';
 import util from 'util';
-import {PageContext, PluginOptions, Resources} from '../types';
+import {match} from 'path-to-regexp';
+import {PageContext, PageOptions, PluginOptions, Resources} from '../types';
 
 const readFile = util.promisify(fs.readFile);
 const glob = util.promisify(_glob);
@@ -32,39 +33,82 @@ export const onCreatePage = async (
   }
 
   const {createPage, deletePage} = actions;
-  const {defaultLanguage = 'en', languages = ['en'], path} = pluginOptions;
+  const {defaultLanguage = 'en', languages = ['en'], pages = []} = pluginOptions;
 
-  const generatePage = async (language: string, routed = false): Promise<Page<PageContext>> => {
-    const resources = await getResources(path, language);
-    const newPath = routed ? `${language}${page.path}` : page.path;
+  type GeneratePageParams = {
+    language: string;
+    path?: string;
+    originalPath?: string;
+    routed?: boolean;
+    pageOptions?: PageOptions;
+  };
+  const generatePage = async ({
+    language,
+    path = page.path,
+    originalPath = page.path,
+    routed = false,
+    pageOptions
+  }: GeneratePageParams): Promise<Page<PageContext>> => {
+    const resources = await getResources(pluginOptions.path, language);
     return {
       ...page,
-      path: newPath,
+      path,
       context: {
         ...page.context,
         language,
         i18n: {
           language,
-          languages,
+          languages: pageOptions?.languages || languages,
           defaultLanguage,
           routed,
           resources,
-          originalPath: page.path,
-          path: newPath
+          originalPath,
+          path
         }
       }
     };
   };
 
-  const newPage = await generatePage(defaultLanguage);
+  const pageOptions = pages.find((opt) => match(opt.matchPath)(page.path));
+
+  let newPage;
+  let alternativeLanguages = languages.filter((lng) => lng !== defaultLanguage);
+
+  if (pageOptions?.excludeLanguages) {
+    alternativeLanguages = alternativeLanguages.filter(
+      (lng) => !pageOptions?.excludeLanguages?.includes(lng)
+    );
+  }
+
+  if (pageOptions?.languages) {
+    alternativeLanguages = pageOptions.languages.filter((lng) => lng !== defaultLanguage);
+  }
+
+  if (pageOptions?.getLanguageFromPath) {
+    const result = match<{lang: string}>(pageOptions.matchPath)(page.path);
+    if (!result) return;
+    const language = result.params.lang || defaultLanguage;
+    const originalPath = page.path.replace(`/${language}`, '');
+    const routed = Boolean(result.params.lang);
+    newPage = await generatePage({language, originalPath, routed, pageOptions});
+    if (routed || !pageOptions.excludeLanguages) {
+      alternativeLanguages = [];
+    }
+  } else {
+    newPage = await generatePage({language: defaultLanguage, pageOptions});
+  }
+
   try {
     deletePage(page);
   } catch {}
   createPage(newPage);
 
-  await BP.map(languages, async (lng) => {
-    if (lng === defaultLanguage) return;
-    const localePage = await generatePage(lng, true);
+  await BP.map(alternativeLanguages, async (lng) => {
+    const localePage = await generatePage({
+      language: lng,
+      path: `${lng}${page.path}`,
+      routed: true
+    });
     const regexp = new RegExp('/404/?$');
     if (regexp.test(localePage.path)) {
       localePage.matchPath = `/${lng}/*`;

src/plugin/onCreatePage.ts

@@ -2,13 +2,21 @@ import {InitOptions} from 'i18next';
 
 export const LANGUAGE_KEY = 'gatsby-i18next-language';
 
+export type PageOptions = {
+  matchPath: string;
+  getLanguageFromPath?: boolean;
+  excludeLanguages?: string[];
+  languages?: string[];
+};
+
 export type PluginOptions = {
   languages: string[];
   defaultLanguage: string;
   path: string;
   redirect: boolean;
   siteUrl?: string;
   i18nextOptions: InitOptions;
+  pages: Array<PageOptions>;
 };
 
 export type Resources = Record<string, Record<string, Record<string, string>>>;