Only copy required files to public

Author: garronej

src/bin/copy-dsfr-to-public.ts

@@ -17,6 +17,8 @@ import { getProjectRoot } from "./tools/getProjectRoot";
 import yargsParser from "yargs-parser";
 import { getAbsoluteAndInOsFormatPath } from "./tools/getAbsoluteAndInOsFormatPath";
 import { readPublicDirPath } from "./readPublicDirPath";
+import { transformCodebase } from "./tools/transformCodebase";
+import { assert } from "tsafe/assert";
 
 (async () => {
     const argv = yargsParser(process.argv.slice(2));
@@ -73,7 +75,7 @@ import { readPublicDirPath } from "./readPublicDirPath";
 
     fs.writeFileSync(pathJoin(dsfrDirPath, ".gitignore"), Buffer.from("*", "utf8"));
 
-    (function callee(depth: number) {
+    const dsfrDistNodeModulesDirPath = (function dsfrDistNodeModulesDirPath(depth: number): string {
         const parentProjectDirPath = pathResolve(
             pathJoin(...[projectDirPath, ...new Array(depth).fill("..")])
         );
@@ -93,17 +95,73 @@ import { readPublicDirPath } from "./readPublicDirPath";
                 process.exit(-1);
             }
 
-            callee(depth + 1);
-
-            return;
+            return dsfrDistNodeModulesDirPath(depth + 1);
         }
 
-        fs.cpSync(dsfrDirPathInNodeModules, dsfrDirPath, {
-            "recursive": true
-        });
+        return dsfrDirPathInNodeModules;
     })(0);
+
+    {
+        const dsfrMinCssFileRelativePath = "dsfr.min.css";
+
+        const usedAssetsRelativeFilePaths = new Set(
+            readAssetsImportFromDsfrCss({
+                "dsfrSourceCode": fs
+                    .readFileSync(pathJoin(dsfrDistNodeModulesDirPath, dsfrMinCssFileRelativePath))
+                    .toString("utf8")
+            })
+        );
+
+        const fileToKeepRelativePaths = new Set([
+            pathJoin("favicon", "apple-touch-icon.png"),
+            pathJoin("favicon", "favicon.svg"),
+            pathJoin("favicon", "favicon.ico"),
+            pathJoin("favicon", "manifest.webmanifest"),
+            pathJoin("utility", "icons", "icons.min.css"),
+            dsfrMinCssFileRelativePath
+        ]);
+
+        transformCodebase({
+            "srcDirPath": dsfrDistNodeModulesDirPath,
+            "destDirPath": dsfrDirPath,
+            "transformSourceCode": ({ fileRelativePath, sourceCode }) => {
+                if (
+                    fileToKeepRelativePaths.has(fileRelativePath) ||
+                    usedAssetsRelativeFilePaths.has(fileRelativePath)
+                ) {
+                    return { "modifiedSourceCode": sourceCode };
+                }
+            }
+        });
+    }
 })();
 
+function readAssetsImportFromDsfrCss(params: { dsfrSourceCode: string }): string[] {
+    const { dsfrSourceCode } = params;
+
+    const fileRelativePaths = [/url\("([^"]+)"\)/g, /url\('([^']+)'\)/g, /url\(([^)]+)\)/g]
+        .map(regex => {
+            const fileRelativePaths: string[] = [];
+
+            dsfrSourceCode.replace(regex, (...[, relativeFilePath]) => {
+                if (relativeFilePath.startsWith("data:")) {
+                    return "";
+                }
+
+                fileRelativePaths.push(relativeFilePath);
+
+                return "";
+            });
+
+            return fileRelativePaths;
+        })
+        .flat();
+
+    assert(fileRelativePaths.length !== 0);
+
+    return fileRelativePaths;
+}
+
 function getRepoIssueUrl() {
     const reactDsfrRepoUrl = JSON.parse(
         fs.readFileSync(pathJoin(getProjectRoot(), "package.json")).toString("utf8")

src/bin/tools/crawlSync.ts

@@ -0,0 +1,35 @@
+import * as fs from "fs";
+import { join as pathJoin, relative as pathRelative } from "path";
+
+const crawlSyncRec = (dirPath: string, filePaths: string[]) => {
+    for (const basename of fs.readdirSync(dirPath)) {
+        const fileOrDirPath = pathJoin(dirPath, basename);
+
+        if (fs.lstatSync(fileOrDirPath).isDirectory()) {
+            crawlSyncRec(fileOrDirPath, filePaths);
+
+            continue;
+        }
+
+        filePaths.push(fileOrDirPath);
+    }
+};
+
+/** List all files in a given directory return paths relative to the dir_path */
+export function crawlSync(params: {
+    dirPath: string;
+    returnedPathsType: "absolute" | "relative to dirPath";
+}): string[] {
+    const { dirPath, returnedPathsType } = params;
+
+    const filePaths: string[] = [];
+
+    crawlSyncRec(dirPath, filePaths);
+
+    switch (returnedPathsType) {
+        case "absolute":
+            return filePaths;
+        case "relative to dirPath":
+            return filePaths.map(filePath => pathRelative(dirPath, filePath));
+    }
+}

src/bin/tools/transformCodebase.ts

@@ -0,0 +1,84 @@
+import * as fs from "fs";
+import * as path from "path";
+import { crawlSync } from "./crawlSync";
+
+type TransformSourceCode = (params: {
+    sourceCode: Buffer;
+    filePath: string;
+    fileRelativePath: string;
+}) =>
+    | {
+          modifiedSourceCode: Buffer;
+          newFileName?: string;
+      }
+    | undefined;
+
+/**
+ * Apply a transformation function to every file of directory
+ * If source and destination are the same this function can be used to apply the transformation in place
+ * like filtering out some files or modifying them.
+ * */
+export function transformCodebase(params: {
+    srcDirPath: string;
+    destDirPath: string;
+    transformSourceCode?: TransformSourceCode;
+}) {
+    const { srcDirPath, transformSourceCode } = params;
+
+    const isTargetSameAsSource = path.relative(srcDirPath, params.destDirPath) === "";
+
+    const destDirPath = isTargetSameAsSource
+        ? path.join(srcDirPath, "..", "tmp_xOsPdkPsTdzPs34sOkHs")
+        : params.destDirPath;
+
+    fs.mkdirSync(destDirPath, {
+        recursive: true
+    });
+
+    for (const fileRelativePath of crawlSync({
+        dirPath: srcDirPath,
+        returnedPathsType: "relative to dirPath"
+    })) {
+        const filePath = path.join(srcDirPath, fileRelativePath);
+        const destFilePath = path.join(destDirPath, fileRelativePath);
+
+        // NOTE: Optimization, if we don't need to transform the file, just copy
+        // it using the lower level implementation.
+        if (transformSourceCode === undefined) {
+            fs.mkdirSync(path.dirname(destFilePath), {
+                recursive: true
+            });
+
+            fs.copyFileSync(filePath, destFilePath);
+
+            continue;
+        }
+
+        const transformSourceCodeResult = transformSourceCode({
+            sourceCode: fs.readFileSync(filePath),
+            filePath,
+            fileRelativePath
+        });
+
+        if (transformSourceCodeResult === undefined) {
+            continue;
+        }
+
+        fs.mkdirSync(path.dirname(destFilePath), {
+            recursive: true
+        });
+
+        const { newFileName, modifiedSourceCode } = transformSourceCodeResult;
+
+        fs.writeFileSync(
+            path.join(path.dirname(destFilePath), newFileName ?? path.basename(destFilePath)),
+            modifiedSourceCode
+        );
+    }
+
+    if (isTargetSameAsSource) {
+        fs.rmSync(srcDirPath, { recursive: true });
+
+        fs.renameSync(destDirPath, srcDirPath);
+    }
+}