5htp 0.0.2

package/src/compiler/common/plugins/indexage/icones-svg/index.ts

@@ -0,0 +1,198 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import fs from 'fs-extra';
+import webfont from 'webfont';
+import defaultMetadataProvider from 'svgicons2svgfont/src/metadata';
+
+// Libs
+import Indexeur from '../indexeur';
+import cli from '@cli';
+
+// Configs
+const formats = ['woff2'];
+const dossierIcones = cli.paths.core.src + '/client/assets/icons/';
+const dossierSortie = cli.paths.app.bin + '/public/'; 
+
+const cacheTypes = cli.paths.core.src + '/types/icons.d.ts';
+const cacheIndex = dossierIcones + 'index.json';
+
+// Types
+import type { TIndexIcones } from '../../../babel/plugins/icones-svg';
+
+/*----------------------------------
+- UTILS
+----------------------------------*/
+const refExistant = (dir: string): string[] => {
+
+    let filelist: string[] = [];
+
+    let files = fs.readdirSync(dossierIcones + dir);
+    for (const file of files)
+        if (fs.statSync(dossierIcones + dir + file).isDirectory())
+            filelist = [
+                ...filelist,
+                ...refExistant(dir + file + '/')
+            ];
+        else if (file.endsWith('.svg'))
+            filelist.push(dir + file.substring(0, file.length - 4));
+
+    return filelist;
+};
+
+/*----------------------------------
+- PLUGIN
+----------------------------------*/
+export default class SelecteursApi extends Indexeur {
+
+    private icones: TIndexIcones = {};
+    private iconesExistantes: string[] = [];
+
+    public constructor() {
+        super();
+
+        if (fs.existsSync(cacheIndex)) {
+
+            console.log('[icones] Getting icons list from cache ...');
+            this.iconesExistantes = fs.readJSONSync(cacheIndex);
+
+        } else {
+
+            console.log('[icones] Référencement des icones existantes ...');
+            this.iconesExistantes = refExistant('');
+            fs.outputJSONSync(cacheIndex, this.iconesExistantes);
+
+        }
+
+        console.log('[icones] ' + this.iconesExistantes.length + ' icones référencées');
+    }
+
+    /*----------------------------------
+    - EVENTS
+    ----------------------------------*/
+    public Init() {
+
+       
+        
+    }
+
+    public Maj( donneesMeta: TIndexIcones, fichier: string): boolean {
+
+        let maj = false;
+
+        // Pour chacune d'entre elles
+        for (const cheminIcone in donneesMeta) {
+
+            // Verif si existante
+            if (!this.iconesExistantes.includes( cheminIcone ))
+                console.error(`L'icone ${donneesMeta[cheminIcone].nom} (${cheminIcone}) utilisée dans le fichier ${fichier} n'existe pas.`);
+            // Verif si déjà référencée
+            else if (this.icones[ cheminIcone ] === undefined) {
+                // Sinon, référencement
+                this.icones[ cheminIcone ] = donneesMeta[ cheminIcone ];
+
+                //console.log('Nouvelle icone', donneesMeta[ cheminIcone ].nom);
+                maj = true;
+            }
+        }
+
+        return maj;
+    }
+
+    public async Enregistrer() {
+
+        //return []
+
+        let cheminIcones: {[chemin: string]: string} = {};
+        let typeIcones: string[] = [];
+        for (const id in this.icones) {
+            const icone = this.icones[id]
+            cheminIcones[ dossierIcones + icone.fichier ] = icone.id;
+            typeIcones.push('"' + icone.nom + '"');
+        }
+
+        console.log('[icones] Création police avec ' + typeIcones.length +' icones ...');
+        //console.log('[icones] Liste des icones rféérencées: ', cheminIcones);
+
+        const optionsMetadata = {
+            // Options par défaut de webfont
+            // https://github.com/itgalaxy/webfont/blob/cc4412f0ff1f811bb7d38b5da75e128c270d4e6b/src/standalone.js#L203
+            // RAPPEL: startUnicode sera incrémenté dans defaultMetadataProvider (https://github.com/nfroidure/svgicons2svgfont/blob/master/src/metadata.js#L61), 
+            //          c'est pourquoi on déclare les options dans un objet
+            prependUnicode: false,
+            startUnicode: 0xea01
+        }
+
+        const result = await webfont({
+            files: Object.keys(cheminIcones),
+            fontName: "icons",
+            template: dossierIcones + 'template.css',
+            // @ts-ignore
+            formats,
+            templateClassName: 'svg',
+            glyphTransformFn: (obj) => {
+                
+                // Nom classe css = via id
+                const icone = this.icones[obj.path]
+                if (icone !== undefined)
+                    obj.name = icone.id;
+
+                return obj;
+            },
+            // Par défaut, le nom des icones est déterminé via le nom du fichier uniquement
+            // Ici, onrefixe le nom des glyphs de leur set (solid, regular) afin de pouvoir utiliser plusieurs sets pour une même icone
+            // ex: solid/home et regular/home
+            metadataProvider: (file, callback) => {
+                
+                // BUG: Quand defaultMetadataProvider est appellé manuellement, l'unicode est toujours le même peu importe l'icone
+                // Incmrémenter l'unicde manuellement ? https://stackoverflow.com/questions/12504042/what-is-a-method-that-can-be-used-to-increment-letters
+                defaultMetadataProvider(optionsMetadata)(file, (err, defaultMetas) => {
+
+                    const idIcone = cheminIcones[ file ];
+                    if (idIcone === undefined)
+                        console.warn("Impossible de retrouver l'id de l'icone " + file);
+                    else
+                        defaultMetas.name = idIcone;
+
+                    callback(err, defaultMetas);
+
+                    optionsMetadata.startUnicode++;
+
+                });
+            }
+        })
+            .catch(error => {
+                console.error("Erreur lors de la création de la police d'icones", error);
+                throw error;
+            });
+
+        console.log('[icones] Enregistrement de la police avec ' + typeIcones.length +' icones ...');
+
+        // Enregistrement fichiers
+        for (const format of formats)
+            fs.outputFileSync(dossierSortie + 'icons.' + format, result[ format ]);
+        fs.outputFileSync(dossierSortie + 'icons.css', result.template);
+
+        fs.outputFileSync(cacheTypes, 'export type TIcones = ' + typeIcones.join('|') );
+
+        console.log("[icones] Police enregistrée.");
+
+        return [
+            /*{ 
+                fichier: dossierSortie + 'index.css', 
+                donnees: result.template 
+            },
+            ...formats.map((format) => ({
+                fichier: dossierSortie + 'icones.' + format,
+                donnees: result[ format ]
+            }))*/
+        ];
+    
+    }
+
+    /*----------------------------------
+    - OUTILS
+    ----------------------------------*/
+}

package/src/compiler/common/plugins/indexage/index.ts

@@ -0,0 +1,132 @@
+import Indexeur from './indexeur';
+
+import { Compiler } from 'webpack';
+
+type TListeIndexeurs = {[nom: string]: Indexeur}
+
+export default class SelecteursApiPlugin {
+
+    public static metadataContextFunctionName = "metadataSelecteursApiPlugin";
+
+    private indexeurs: TListeIndexeurs;
+
+    public constructor(config: TListeIndexeurs) {
+
+        this.indexeurs = config;
+
+    }
+
+    apply(compiler: Compiler) {
+
+        const nomCompileur = compiler.options.name;
+
+        for (const nomIndexeur in this.indexeurs) {
+            console.log(`[indexage][${nomCompileur}][${nomIndexeur}] Init`);
+            this.indexeurs[nomIndexeur].Init();
+        }
+
+        compiler.hooks.compilation.tap("SelecteursApiPlugin", (compilation) => {
+            //console.log("The compiler is starting a new compilation...");
+
+            compilation.hooks.normalModuleLoader.tap("SelecteursApiPlugin", (context, module) => {
+
+                // Fonction de récupération des métadatas
+                context["metadataSelecteursApiPlugin"] = (metadata) => {
+
+                    //console.log(`[selecteurs-api] Meta reçues ` +  module.resource, metadata);
+
+                    for (const nomIndexeur in this.indexeurs)
+                        if (metadata[nomIndexeur] !== undefined) {
+
+                            const majOk = this.indexeurs[nomIndexeur].Maj(metadata[nomIndexeur], module.resource);
+
+                            if (majOk) {
+
+                                /*if (this.indexeurs[ nomIndexeur ].compile[ module.resource ] !== undefined) {
+                                    console.log(`[indexage][${nomCompileur}][${nomIndexeur}] Màj via le fichier ${module.resource}`);
+                                }*/
+
+                                this.indexeurs[nomIndexeur].compile[module.resource] = true;
+                                this.indexeurs[nomIndexeur].derniereModif = new Date().getTime();
+                            }
+
+                        }
+                }
+
+            })
+        })
+
+        // A partir de finishModules, webpack n'accepte plus les modifs de modules
+        // https://webpack.js.org/api/compilation-hooks/#seal
+        // https://github.com/webpack/webpack/issues/8830
+        compiler.hooks.thisCompilation.tap("SelecteursApiPlugin", (compilation) => {
+            compilation.hooks.finishModules.tapAsync("SelecteursApiPlugin", async (modules, callback) => {
+
+                for (const nomIndexeur in this.indexeurs) {
+                    try {
+                        if (this.indexeurs[nomIndexeur].derniereModif > this.indexeurs[nomIndexeur].derniereMaj) {
+
+                            console.log(`[indexage][${nomCompileur}][${nomIndexeur}] Enregistrement des modifications`);
+
+                            this.indexeurs[nomIndexeur].derniereMaj = this.indexeurs[nomIndexeur].derniereModif;
+                            const aEnregistrer = await this.indexeurs[nomIndexeur].Enregistrer();
+                            /*for (const { fichier, donnees } of aEnregistrer) {
+
+                                console.info("TODO: indexag weback")
+
+
+                                 TODO:
+                                const moduleAmaj = Array.from(modules).find(
+                                    // m.id peut êtreun nombre ou null. Pour rechercher via le chemin, m.resource
+                                    (m) => m.resource && m.resource.endsWith(fichier)
+                                );
+
+                                if (!moduleAmaj) {
+                                    console.warn(`[indexage][${nomCompileur}][${nomIndexeur}]  Impossible de retrouver le module correspondant au fichier ${fichier}`);
+                                    continue;
+                                }
+
+                                console.log(`[indexage][${nomCompileur}][${nomIndexeur}] Màj & recompilation du module ${moduleAmaj.resource} ...`);
+
+                                moduleAmaj._source._value = donnees;
+
+                                // Recompile immédiatement et sans devoir changer le fichier
+                                moduleAmaj.parser.parse(
+                                    moduleAmaj._source.source(),
+                                    {
+                                        current: moduleAmaj,
+                                        module: moduleAmaj,
+                                        compilation: compilation,
+                                        options: compilation.options
+                                    }
+                                );
+
+                                // ALTERNATIVE: Rien ne se passe
+                                //compiler.hooks.invalid.call(moduleAmaj.resource, Date.now());
+                                compilation.rebuildModule( moduleAmaj, (e) => {
+
+                                    if (e) console.error(e);
+                                    else {
+
+                                        callback();
+
+                                    }
+
+                                });
+
+                            }*/
+                        }
+                    } catch (e) {
+
+                        console.error(`Erreur lors de l'enregistrement des sélecteurs api: `, e);
+                        throw e;
+
+                    }
+                }
+
+                callback();
+
+            });
+        });
+    }
+}

package/src/compiler/common/plugins/indexage/indexeur.ts

@@ -0,0 +1,13 @@
+type DonneesAenregistrer = { fichier: string, donnees: string }
+
+export default abstract class Indexeur {
+
+    public compile = {};
+    public derniereMaj = 0; 
+    public derniereModif = 0;
+
+    public abstract Init(): void;
+    public abstract Maj( donneesMetas: any, fichier: string ): boolean;
+    public abstract Enregistrer(): Promise< DonneesAenregistrer[] >;
+
+}

package/src/compiler/common/plugins/indexage/injection-dependances/index.ts

@@ -0,0 +1,68 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import fs from 'fs-extra';
+
+// Libs
+import Indexeur from '../indexeur';
+import Stringify from '../_utils/Stringify';
+import cli from '@cli';
+
+const fichierSortie = cli.paths.app.cache + '/serveur/services.ts';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+type TService = {
+    classe?: any,
+    dependances: string[]
+}
+
+type TListeServices = {[idService: string]: TService};
+
+/*----------------------------------
+- PLUGIN
+----------------------------------*/
+export default class SelecteursApi extends Indexeur {
+
+    private dependances: TListeServices = {};
+
+    /*----------------------------------
+    - EVENTS
+    ----------------------------------*/
+    public Init() {
+
+        // Autrement, erreur compilation comme quoi que le module n'existe pas
+        // En effet, le dossier cache est vidé avant la compilation
+        // Et le fichierd'index des déps n'est généré qu'à la fin de la compilation
+        fs.outputFileSync(fichierSortie, 'export default {}');
+        
+    }
+
+    public Maj(nouveauxServices: TListeServices, fichier: string): boolean {
+
+        let maj = false;
+
+        for (const idService in nouveauxServices) {
+
+            maj = true;
+
+            this.dependances[idService] = nouveauxServices[idService];
+
+        }
+
+        return maj;
+    }
+
+    public async Enregistrer() {
+
+        console.log('enregistrer dépendances', this.dependances);
+
+        fs.outputFileSync(fichierSortie, 'export default ' + Stringify(this.dependances, ['classe']));
+
+        return [];
+    
+    }
+}

package/src/compiler/index.ts

@@ -0,0 +1,86 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import webpack from 'webpack';
+import fs from 'fs-extra';
+
+import SpeedMeasurePlugin from "speed-measure-webpack-plugin";
+const smp = new SpeedMeasurePlugin({ disable: true });
+
+// Core
+import createServerConfig from './server';
+import createClientConfig from './client';
+import { TCompileMode } from './common';
+import cli from '../';
+
+type TCompilerCallback = () => void
+
+/*----------------------------------
+- FONCTION
+----------------------------------*/
+export const compiling: { [compiler: string]: Promise<void> } = {};
+
+export default async function createCompilers( 
+    mode: TCompileMode,
+    { before, after }: {
+        before?: TCompilerCallback,
+        after?: TCompilerCallback,
+    } = {}
+) {
+
+    // Cleanup
+    fs.emptyDirSync( cli.paths.app.bin );
+
+    // Create compilers
+    const multiCompiler = webpack([
+        smp.wrap( createServerConfig(mode) ),
+        smp.wrap( createClientConfig(mode) )
+    ]);
+
+    for (const compiler of multiCompiler.compilers) {
+
+        const name = compiler.name;
+        if (name === undefined)
+            throw new Error(`A name must be specified to each compiler.`);
+
+        let timeStart = new Date();
+
+        let finished: (() => void);
+        compiling[name] = new Promise((resolve) => finished = resolve);
+
+        compiler.hooks.compile.tap(name, () => {
+
+            before && before();
+
+            compiling[name] = new Promise((resolve) => finished = resolve);
+
+            timeStart = new Date();
+            console.info(`[${name}] ########## Compiling ...`);
+        });
+
+        /* TODO: Ne pas résoudre la promise tant que la recompilation des données indexées (icones, identité, ...) 
+            n'a pas été achevée */
+        compiler.hooks.done.tap(name, stats => {
+
+            // Affiche les détails de la compilation
+            console.info(stats.toString(compiler.options.stats));
+
+            // Shiow status
+            const timeEnd = new Date();
+            const time = timeEnd.getTime() - timeStart.getTime();
+            if (stats.hasErrors()) {
+                console.error(`############## Failed to compile '${name}' after ${time} ms`);
+            } else {
+                console.info(`############## [${name}] Finished compilation after ${time} ms`);
+            }
+
+            // Mark as finished
+            finished();
+            delete compiling[name];
+        });
+    }
+
+    return multiCompiler;
+}

package/src/compiler/server/index.ts

@@ -0,0 +1,177 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import webpack from 'webpack';
+import TsAlias from 'ts-alias';
+import path from 'path';
+
+// Plugins
+var nodeExternals = require('webpack-node-externals');
+
+// Minimizers
+const TerserPlugin = require("terser-webpack-plugin");
+//var VirtualModulesPlugin = require('webpack-virtual-modules');
+
+// Core
+import cli from '@cli';
+import createCommonConfig, { TCompileMode, regex } from '../common';
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+export default function createCompiler( mode: TCompileMode ): webpack.Configuration {
+
+    console.info(`Creating compiler for server (${mode}).`);
+    const dev = mode === 'dev';
+
+    const commonConfig = createCommonConfig('server', mode);
+
+    const { aliases } = cli.paths.aliases.server.forWebpack(cli.paths.app.root + '/node_modules');
+        
+    const config: webpack.Configuration = {
+
+        ...commonConfig,
+
+        name: 'server',
+        target: 'node',
+        entry: {
+            server: [
+                cli.paths.app.root + '/src/server/index.ts',
+            ],
+        },
+
+        output: {
+
+            pathinfo: dev,
+
+            libraryTarget: 'commonjs2',
+
+            path: cli.paths.app.bin,
+            filename: '[name].js',
+            publicPath: '/',
+            assetModuleFilename: 'public/[hash][ext]',
+
+            chunkFilename: 'chunks/[name].js',
+            // HMR
+            hotUpdateMainFilename: 'updates/[fullhash].hot-update.json',
+            hotUpdateChunkFilename: 'updates/[id].[fullhash].hot-update.js',
+
+        },
+
+        externalsPresets: { node: true }, // in order to ignore built-in modules like path, fs, etc.
+        externals: [
+
+            './chunk-manifest.json',
+            './asset-manifest.json',
+
+            // node_modules
+            function ({ request }, callback) {
+
+                const shouldCompile = request !== undefined && (
+                    request[0] === '.'
+                    ||
+                    request[0] === '/'
+                    ||
+                    cli.paths.aliases.server.containsAlias(request)
+                )
+
+                //console.log('isNodeModule', request, isNodeModule);
+
+                if (!shouldCompile) {
+                    
+                    // Externalize to a commonjs module using the request path
+                    return callback(null, 'commonjs ' + request);
+                }
+
+                // Continue without externalizing the import
+                callback();
+            },
+        ],
+
+        resolve: {
+
+            ...commonConfig.resolve,
+
+            alias: {
+                ...aliases,
+                "@root": cli.paths.app.root,
+            },
+
+            extensions: ['.ts', '.tsx', ".json", ".sql"],
+        },
+
+        module: {
+            // Make missing exports an error instead of warning
+            strictExportPresence: true,
+
+            rules: [
+                {
+                    test: regex.scripts,
+                    include: [
+
+                        cli.paths.app.root + '/src/client',
+                        cli.paths.core.root + '/src/client',
+
+                        cli.paths.app.root + '/src/common',
+                        cli.paths.core.root + '/src/common',
+
+                        // Dossiers server uniquement pour le bundle server
+                        cli.paths.app.root + '/src/server',
+                        cli.paths.core.root + '/src/server'
+                    ],
+                    rules: require('../common/babel')('server', dev)
+                }, 
+
+                // Les pages étan tà la fois compilées dans le bundle client et serveur
+                // On ne compile les ressources (css) qu'une seule fois (coté client)
+                {
+                    test: regex.style,
+                    loader: 'null-loader'
+                },
+
+                ...require('../common/files/images')(dev, false),
+
+                ...require('../common/files/autres')(dev, false),
+
+                // Exclude dev modules from production build
+                /*...(dev ? [] : [
+                    {
+                        test: cli.paths.app.root + '/node_modules/react-deep-force-update/lib/index.js'),
+                        loader: 'null-loader',
+                    },
+                ]),*/
+            ],
+        },
+
+        plugins: [
+
+            ...(commonConfig.plugins || [])
+        ],
+
+        optimization: {
+            minimizer: [
+                new TerserPlugin({
+                    terserOptions: {
+                        // Consere les classnames
+                        keep_classnames: true,
+                        keep_fnames: true
+                    }
+                }),
+            ]
+        },
+
+        // https://webpack.js.org/configuration/devtool/#devtool
+        devtool: /*dev 
+            ? 'eval-source-map' // Recommended choice for development builds with high quality SourceMaps.
+            :*/ 'source-map', // Recommended choice for production builds with high quality SourceMaps.
+
+            // eval-source-map n'est pas précis
+        /*devServer: {
+            hot: true,
+        },*/
+    };
+
+    return config;
+};