Hello World {
+ test("with frontmatter in source", () => {
+ expect(
+ extractFrontmatterFromAstroSource(
+ `---\nconsole.log("Hello World");\n---\n
`
+ )
+ ).toBe(`\nconsole.log("Hello World");\n`);
+ });
+
+ test("without frontmatter in source", () => {
+ expect(extractFrontmatterFromAstroSource(`
Hello World {
+ test("replaces frontmatter in source", () => {
+ expect(
+ overwriteAstroFrontmatter(
+ `---\nconsole.log("Hello World");\n---\n
Hello world
`,
+ `console.log("Howdy World!");`
+ )
+ ).toBe(`---\nconsole.log("Howdy World!");\n---\n
Hello world
`);
+ });
+
+ test("adds frontmatter if no frontmatter is present", () => {
+ expect(
+ overwriteAstroFrontmatter(
+ `
Hello world
`,
+ `console.log("Howdy World!");`
+ )
+ ).toBe(`---\nconsole.log("Howdy World!");\n---\n
Hello world
`);
+ });
+});
diff --git a/src/cli/generate.ts b/src/cli/generate.ts
new file mode 100644
index 0000000..b38a82e
--- /dev/null
+++ b/src/cli/generate.ts
@@ -0,0 +1,68 @@
+import fs from "fs";
+import {
+ crawlInputDirectory,
+ createFiles,
+ FileToGenerate,
+ generateLocalizedFrontmatter,
+ overwriteAstroFrontmatter,
+ parseFrontmatter,
+} from "./utils";
+
+/**
+ * Reads all files inside inputPath
+ *
+ * @param inputPath
+ * @param languages
+ * @param outputPath
+ */
+export const generate = (
+ inputPath: string,
+ defaultLanguage: string,
+ languages: string[],
+ outputPath: string = inputPath
+) => {
+ const files = crawlInputDirectory(inputPath);
+
+ const allLanguages = [defaultLanguage, ...languages];
+
+ const filesToGenerate: FileToGenerate[] = [];
+
+ files.forEach(async function (file) {
+ const inputFilePath = [inputPath, file].join("/");
+ const extension = file.split(".").pop();
+
+ // only parse astro files
+ if (extension === "astro") {
+ const fileContents = fs.readFileSync(inputFilePath);
+ const fileContentsString = fileContents.toString();
+
+ const parsedFrontmatter = parseFrontmatter(fileContentsString);
+
+ allLanguages.forEach((language) => {
+ const frontmatterCode = generateLocalizedFrontmatter(
+ parsedFrontmatter,
+ language
+ );
+
+ // get the astro file contents
+ const newFileContents = overwriteAstroFrontmatter(
+ fileContentsString,
+ frontmatterCode
+ );
+
+ filesToGenerate.push({
+ path: [
+ outputPath,
+ language === defaultLanguage ? null : language,
+ file,
+ ]
+ .filter(Boolean)
+ .join("/"),
+ source: newFileContents,
+ });
+ });
+ }
+ });
+
+ createFiles(filesToGenerate);
+};
diff --git a/src/cli/index.ts b/src/cli/index.ts
new file mode 100755
index 0000000..60fa0b8
--- /dev/null
+++ b/src/cli/index.ts
@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { generate } from "./generate";
+import { isLocale } from "./utils";
+
+interface GenerateArgs {
+ path: string;
+ defaultLanguage: string;
+ languages: string[];
+ output: string;
+}
+
+yargs(hideBin(process.argv))
+ .usage("usage: $0
")
+ .command(
+ "generate [path] [options]",
+ "generates localized Astro pages",
+ (yargs) => {
+ return yargs
+ .positional("path", {
+ type: "string",
+ description: "Path to base pages folder",
+ default: "./src/pages",
+ })
+ .options({
+ "default-language": {
+ alias: "d",
+ type: "string",
+ description: "Set the default language",
+ demandOption: true,
+ },
+ languages: {
+ alias: "l",
+ type: "array",
+ string: true,
+ description: "Provide a list of locales to generate",
+ demandOption: true,
+ },
+ output: {
+ alias: "o",
+ type: "string",
+ description:
+ "Set the output of the generated pages if different from input",
+ default: "./src/pages",
+ },
+ })
+ .check((argv) => {
+ const { "default-language": defaultLanguage, languages } = argv;
+
+ const errors = [];
+
+ if (!isLocale(defaultLanguage)) {
+ errors.push(`"${defaultLanguage}" is not a valid locale!`);
+ }
+
+ languages.forEach((language) => {
+ if (!isLocale(language)) {
+ errors.push(`"${language}" is not a valid locale!`);
+ }
+ });
+
+ if (errors.length > 0) {
+ throw new Error(errors.join("\n"));
+ }
+
+ return true;
+ });
+ },
+ (argv) => {
+ if (argv.verbose) {
+ console.info(`Generating localized pages: ${argv.languages}`);
+ }
+
+ generate(argv.path, argv.defaultLanguage, argv.languages, argv.output);
+ }
+ )
+ .options({
+ verbose: {
+ alias: "v",
+ type: "boolean",
+ description: "Run with verbose logging",
+ },
+ })
+ .parse();
diff --git a/src/cli/transformer.ts b/src/cli/transformer.ts
new file mode 100644
index 0000000..1c66a07
--- /dev/null
+++ b/src/cli/transformer.ts
@@ -0,0 +1,143 @@
+import ts from "typescript";
+
+/**
+ * Traverse ts' AST to inject i18next's language switch
+ * @param context
+ * @returns
+ */
+export const transformer: ts.TransformerFactory =
+ (context: ts.TransformationContext) => (rootNode) => {
+ const { factory, getCompilerOptions } = context;
+ let doesI18nextImportExist = false;
+
+ const { language } = getCompilerOptions();
+
+ function visit(node: ts.Node): ts.Node {
+ // isolate i18next import statement
+ if (
+ ts.isImportDeclaration(node) &&
+ ts.isStringLiteral(node.moduleSpecifier) &&
+ node.moduleSpecifier.text === "i18next" &&
+ ts.isImportClause(node.importClause)
+ ) {
+ doesI18nextImportExist = true;
+
+ if (!node.importClause.namedBindings) {
+ return factory.updateImportDeclaration(
+ node,
+ node.decorators,
+ node.modifiers,
+ factory.createImportClause(
+ node.importClause.isTypeOnly,
+ node.importClause.name,
+ factory.createNamedImports([
+ factory.createImportSpecifier(
+ false,
+ undefined,
+ factory.createIdentifier("changeLanguage")
+ ),
+ ])
+ ),
+ node.moduleSpecifier,
+ node.assertClause
+ );
+ }
+
+ if (
+ ts.isImportClause(node.importClause) &&
+ ts.isNamedImports(node.importClause.namedBindings) &&
+ !node.importClause.namedBindings.elements.find(
+ (namedImport) => namedImport.name.escapedText === "changeLanguage"
+ )
+ ) {
+ // import changeLanguage function in i18next import declaration
+ return factory.updateImportDeclaration(
+ node,
+ node.decorators,
+ node.modifiers,
+ factory.updateImportClause(
+ node.importClause,
+ false,
+ node.importClause.name,
+ factory.updateNamedImports(node.importClause.namedBindings, [
+ ...node.importClause.namedBindings.elements,
+ factory.createImportSpecifier(
+ false,
+ undefined,
+ factory.createIdentifier("changeLanguage")
+ ),
+ ])
+ ),
+ node.moduleSpecifier,
+ node.assertClause
+ );
+ }
+
+ return node;
+ }
+
+ // remove any occurrence of changeLanguage() call
+ if (
+ ts.isExpressionStatement(node) &&
+ ts.isCallExpression(node.expression) &&
+ ((ts.isPropertyAccessExpression(node.expression.expression) &&
+ node.expression.expression.name.escapedText === "changeLanguage") ||
+ (ts.isIdentifier(node.expression.expression) &&
+ node.expression.expression.escapedText === "changeLanguage"))
+ ) {
+ return undefined;
+ }
+
+ return ts.visitEachChild(node, visit, context);
+ }
+
+ let visitedNode = ts.visitNode(rootNode, visit);
+
+ let statements: ts.NodeArray = factory.createNodeArray([
+ ...visitedNode.statements,
+ // append the changeLanguageStatement after a new line
+ factory.createIdentifier("\n") as unknown as ts.Statement,
+ factory.createExpressionStatement(
+ factory.createCallExpression(
+ factory.createIdentifier("changeLanguage"),
+ undefined,
+ [factory.createStringLiteral(language as string)]
+ )
+ ),
+ ]);
+
+ if (!doesI18nextImportExist) {
+ statements = factory.createNodeArray([
+ factory.createImportDeclaration(
+ undefined,
+ undefined,
+ factory.createImportClause(
+ false,
+ undefined,
+ factory.createNamedImports([
+ factory.createImportSpecifier(
+ false,
+ undefined,
+ factory.createIdentifier("changeLanguage")
+ ),
+ ])
+ ),
+ factory.createStringLiteral("i18next"),
+ undefined
+ ),
+ ...statements,
+ ]);
+ }
+
+ visitedNode = factory.updateSourceFile(
+ visitedNode,
+ statements,
+ visitedNode.isDeclarationFile,
+ visitedNode.referencedFiles,
+ visitedNode.typeReferenceDirectives,
+ visitedNode.hasNoDefaultLib,
+ visitedNode.libReferenceDirectives
+ );
+
+ return visitedNode;
+ };
diff --git a/src/cli/utils.ts b/src/cli/utils.ts
new file mode 100644
index 0000000..d00d3d1
--- /dev/null
+++ b/src/cli/utils.ts
@@ -0,0 +1,117 @@
+import { fdir, PathsOutput } from "fdir";
+import fsExtra from "fs-extra";
+import ISO6391 from "iso-639-1";
+import ISO33661a2 from "iso-3166-1-alpha-2";
+import path from "path";
+import fs from "fs";
+import ts from "typescript";
+import { transformer } from "./transformer";
+
+export interface FileToGenerate {
+ path: string;
+ source: string;
+}
+
+/* istanbul ignore next */
+/**
+ * parse frontmatter using typescript compiler
+ *
+ * @param source
+ */
+export const parseFrontmatter = (source: string): ts.SourceFile =>
+ ts.createSourceFile(
+ "x.ts",
+ extractFrontmatterFromAstroSource(source),
+ ts.ScriptTarget.Latest
+ );
+
+/* istanbul ignore next */
+export const generateLocalizedFrontmatter = (
+ tsNode: ts.SourceFile,
+ language: string
+) => {
+ // generate for default language, then loop over languages to generate other pages
+ const result: ts.TransformationResult = ts.transform(
+ tsNode,
+ [transformer],
+ { language }
+ );
+ const printer = ts.createPrinter();
+
+ return printer.printNode(
+ ts.EmitHint.Unspecified,
+ result.transformed[0],
+ tsNode
+ );
+};
+
+/* istanbul ignore next */
+export const crawlInputDirectory = (directoryPath: string): PathsOutput => {
+ // eslint-disable-next-line new-cap
+ const api = new fdir()
+ .exclude((dirName) => isLocale(dirName))
+ .withRelativePaths()
+ .crawl(directoryPath);
+
+ return api.sync() as PathsOutput;
+};
+
+export const isLocale = (code: string): boolean => {
+ const REGEX = /^(?[a-z]{2})(-(?[A-Z]{2}))?$/;
+
+ if (!REGEX.test(code)) {
+ return false;
+ }
+
+ const {
+ groups: { iso6391, iso33661a2 },
+ } = REGEX.exec(code);
+
+ if (iso33661a2 && !ISO33661a2.getCountry(iso33661a2)) {
+ return false;
+ }
+
+ if (!ISO6391.validate(iso6391)) {
+ return false;
+ }
+
+ return true;
+};
+
+export const doesStringIncludeFrontmatter = (source: string): boolean =>
+ /---.*---/s.test(source);
+
+export const extractFrontmatterFromAstroSource = (source: string): string => {
+ let frontmatterSource = "";
+ if (doesStringIncludeFrontmatter(source)) {
+ const {
+ groups: { frontmatter },
+ } = /---(?(.*))---/s.exec(source);
+ frontmatterSource = frontmatter;
+ }
+
+ return frontmatterSource;
+};
+
+export const overwriteAstroFrontmatter = (
+ source: string,
+ frontmatter: string
+): string => {
+ let newFileContents = "";
+ if (doesStringIncludeFrontmatter(source)) {
+ newFileContents = source.replace(/---.*---/s, `---\n${frontmatter}\n---`);
+ } else {
+ newFileContents = `---\n${frontmatter}\n---\n` + source;
+ }
+
+ return newFileContents;
+};
+
+/* istanbul ignore next */
+export const createFiles = (filesToGenerate: FileToGenerate[]): void => {
+ filesToGenerate.forEach((fileToGenerate) => {
+ fsExtra.ensureDirSync(path.dirname(fileToGenerate.path));
+
+ fs.writeFileSync(fileToGenerate.path, fileToGenerate.source);
+ });
+};