5htp 0.0.2

package/src/compiler/common/babel/plugins/queries/index.ts

@@ -0,0 +1,166 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import path from 'path';
+import { PluginObj } from '@babel/core';
+import * as types from '@babel/types'
+
+/*----------------------------------
+- REGEX
+----------------------------------*/
+const cheminClasseQuery = '@serveur/database/jsql/query/runner';
+
+const regFichierModele = /^[a-z]+\/serveur\/modeles\//i;
+
+/*----------------------------------
+- WEBPACK RULE
+----------------------------------*/
+module.exports = {// /serveur/**.ts */
+    test: /\/serveur\/(.*)\.(ts)$/i,
+    plugins: [
+        [Plugin]
+    ]
+}
+
+
+/*----------------------------------
+- PLUGIN
+----------------------------------*/
+function Plugin (babel) {
+
+    const t = babel.types as typeof types;
+
+    const plugin: PluginObj<{
+        fichier: string,
+        dossier: string
+    }> = {
+        pre(state) {
+
+            const { filename, root } = state.opts;
+
+            if (!filename)
+                throw new Error(`Impossible d'obtenir le chemin du fichier actuellement rraité par le plugin`);
+
+            if (!root)
+                throw new Error(`Impossible d'obtenir le chemin de la racine du projet`);
+
+            this.fichier = filename;
+
+            const prefixeRoot = root + '/src/'
+            this.dossier = path.dirname(filename).substring(prefixeRoot.length)
+        },
+        visitor: {
+            ImportDeclaration(instruction) {
+
+                if (!(
+                    instruction.node.specifiers.length === 1
+                    &&
+                    instruction.node.specifiers[0].type === 'ImportDefaultSpecifier'
+                ))
+                    return;
+
+                const cheminImportFichier = instruction.node.source.value;
+                const importDefault = instruction.node.specifiers[0];
+
+                /* Recherche de:
+                    import PublicScope from './Public/index.sql';
+                */
+                if (
+                    // Suffise SQL = déjà traité, ou intention de garder le SQL
+                    !importDefault.local.name.endsWith('SQL')
+                    &&
+                    cheminImportFichier.endsWith('.sql')
+                ) {
+
+                    // Extraction des infos
+                    const nomVarScope = importDefault.local.name;
+                    const nomImportSql = nomVarScope + 'SQL';
+                    const cheminCompletImport = path.join(this.dossier, cheminImportFichier);
+
+                    // Génère un ID unique basé sur le chemin
+                    let cheminScope: string = cheminCompletImport;
+                    const isModelScope = regFichierModele.test(cheminCompletImport);
+                    if (isModelScope) {
+                        // Mission.Public
+                        const nomModele = path.basename(this.dossier);
+                        cheminScope = nomModele + '.' + cheminCompletImport.substring(
+                            this.dossier.length + 1, // +1 pour le dernier slash
+                        )
+                    }
+
+                    cheminScope = cheminScope
+                        .substring(0, cheminScope.length - 4) // Vire l'extension .sql
+                        .replace(/\//g, '.');
+
+                    if (cheminScope.endsWith('.index'))
+                        cheminScope = cheminScope.substring(0, cheminScope.length - 6)
+
+                    // Renommage de l'import du sql et instanciaiton de la query
+                    // NOTE: On ne skip pas, puisque les imports ont été suffixés de SQL
+                    //instruction.skip();
+                    let remplacement = []
+
+                    /* Création factory */
+                    remplacement.push(
+
+                        // + import PublicScopeSql from './Public/index.sql';
+                        t.importDeclaration(
+                            [t.importDefaultSpecifier(t.identifier(nomImportSql))],
+                            t.stringLiteral(cheminImportFichier)
+                        ),
+
+                        // + const PublicScope = new String( PublicScopeSql );
+                        t.variableDeclaration('const', [
+                            t.variableDeclarator( 
+                                t.identifier(nomVarScope), 
+                                t.newExpression(
+                                    t.identifier('String'),
+                                    [t.identifier(nomImportSql)]
+                                ) 
+                            )
+                        ]),
+
+                        // + PublicScope.id = 'earn/missions/Mission/Public/index';
+                        t.expressionStatement(
+                            t.assignmentExpression(
+                                '=',
+                                t.memberExpression(
+                                    t.identifier( nomVarScope ),
+                                    t.identifier('id')
+                                ),
+                                t.stringLiteral(cheminScope)
+                            )
+                        ),
+
+                        // + PublicScope.sourceFile = 'earn/missions/Mission/Public/index.sql'
+                        t.expressionStatement(
+                            t.assignmentExpression(
+                                '=',
+                                t.memberExpression(
+                                    t.identifier( nomVarScope ),
+                                    t.identifier('sourceFile')
+                                ),
+                                t.stringLiteral(cheminCompletImport)
+                            )
+                        ),
+                    )
+
+                    /*console.log(`[babel][plugin][queries]`, 
+                        this.fichier, cheminCompletImport, '\n',
+                        recast.print( t.program(remplacement) ).code,
+                        cheminScope
+                    );*/
+
+                    // Remplacement
+                    instruction.replaceWithMultiple(remplacement);
+
+                }
+
+            }
+        }
+    };
+
+    return plugin;
+}

package/src/compiler/common/files/autres.ts

@@ -0,0 +1,37 @@
+import { staticAssetName } from '../../../paths';
+
+module.exports = (dev: boolean, client: boolean) => ([
+
+    // Allow to use ?raw at the end of the module path to iport the raw content only
+    // Example: import VisualParserSource from './Parsers/visual.js?raw';
+    {
+        resourceQuery: /raw/,
+        type: 'asset/source',
+    },
+
+    // Client uniquement: Retourne le fichier correspondant au fichier dans le dossier public
+    {
+        test: /\.(xml|ico|wav|mp3)$/,
+        //loader: 'file-loader',
+        type: 'asset/resource',
+        generator: {
+            filename: staticAssetName
+        }
+    },
+
+    // Texte brut
+    {
+        type: 'asset/source',
+        test: /\.(md|hbs|sql|txt|csv)$/,
+    },
+
+    // Polices dans un fichier distinc dans le dossier dédié
+    {
+        test: /\.(woff(2)?|ttf|eot)(\?v=\d+\.\d+\.\d+)?$/,
+        //loader: 'file-loader',
+        type: 'asset/resource',
+        generator: {
+            filename: 'fonts/[name].[ext]'
+        }
+    }
+])

package/src/compiler/common/files/images.ts

@@ -0,0 +1,19 @@
+import { staticAssetName } from '../../../paths';
+import type webpack from 'webpack';
+
+module.exports = (dev: boolean, client: boolean): webpack.RuleSetRule[] => {
+
+    return [{
+        test: /\.(bmp|gif|jpg|jpeg|png|ico|svg)$/,
+        type: 'asset',
+        parser: {
+            dataUrlCondition: {
+                // https://webpack.js.org/guides/asset-modules/#general-asset-type
+                // < 4kb = importation inline
+                // > 4kb = référence à l'url
+                maxSize: 4 * 1024 // 4kb
+            }
+        }
+
+    }]
+}

package/src/compiler/common/files/style.ts

@@ -0,0 +1,64 @@
+// Plugons
+import MiniCssExtractPlugin from "mini-css-extract-plugin";
+import lessToJs from 'less-vars-to-js';
+
+import fs from 'fs-extra';
+import cli from '@cli';
+
+module.exports = (dev: Boolean, client: boolean) => {
+
+    const paletteLess = fs.readFileSync( cli.paths.app.src + '/client/assets/theme.less', 'utf8');
+    const themeVars = lessToJs(paletteLess, { resolveVariables: true, stripPrefix: true });
+
+    return [
+
+        // Apply PostCSS plugins including autoprefixer
+        {
+            loader: MiniCssExtractPlugin.loader
+        },
+
+        // Process external/third-party styles
+        {
+            exclude: [/*process.env.framework + '/kernel', */cli.paths.app.src],
+            loader: 'css-loader',
+            options: {
+                sourceMap: dev
+            },
+        },
+
+        // Process internal/project styles (from src folder)
+        {
+            include: [/*process.env.framework + '/kernel', */cli.paths.app.src],
+            loader: 'css-loader',
+            options: {
+                // CSS Loader https://github.com/webpack/css-loader
+                importLoaders: 1,
+                sourceMap: dev
+            },
+        },
+
+        {
+            test: /\.less$/,
+            loader: 'less-loader',
+            options: {
+                lessOptions: {
+                    // RAPPEL: Rallonge considéralement le temps de compilation
+                    // Pour math.random
+                    //javascriptEnabled: true
+
+                    // Défault = parens-division depuis 4.0.0
+                    // https://lesscss.org/usage/#less-options-math
+                    math: 'always',
+
+                    globalVars: themeVars
+                },
+            }
+        },
+
+        /*{
+            test: /\.scss/,
+            loader: process.env.framework + '/node_modules/sass-loader',
+        }*/
+    ]
+
+}

package/src/compiler/common/index.ts

@@ -0,0 +1,148 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// npm
+import webpack from 'webpack';
+import dayjs from 'dayjs';
+
+// Plugins
+const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
+import PluginIndexage from './plugins/indexage';
+import IconesSvg from './plugins/indexage/icones-svg';
+import InjectDeps from './plugins/indexage/injection-dependances';
+
+// Core
+import { TAppSide } from '@cli';
+import cli from '../..';
+
+/*----------------------------------
+- CONSTANTS
+----------------------------------*/
+
+export const regex = {
+    scripts: /\.(ts|tsx)$/,
+    style: /\.(css|less|scss)$/,
+    images: /\.(bmp|gif|jpg|jpeg|png|ico|svg)$/, // SVG gérés par SVGR
+    fonts: /\.(woff(2)?|ttf|eot)(\?v=\d+\.\d+\.\d+)?$/,
+    staticAssetName: /*isDebug ? '[name].[ext].[hash:8]' :*/ '[hash:8][ext]',
+}
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TCompileMode = 'dev' | 'prod'
+
+/*----------------------------------
+- BASE CONFIG
+----------------------------------*/
+
+export default function createCommonConfig( side: TAppSide, mode: TCompileMode ): webpack.Configuration {
+
+    const dev = mode === 'dev';
+    const config: webpack.Configuration = {
+
+        // Project root
+        context: cli.paths.app.root,
+
+        mode: dev ? 'development' : 'production',
+
+        resolveLoader: {
+            // Recherche des loaders dans framework/node_modules (psinon, webpack cherche dans le projet)
+            modules: [
+                cli.paths.core.root + '/node_modules'
+            ],
+            mainFields: ['loader', 'main'],
+        },
+
+        plugins: [
+
+            // https://webpack.js.org/plugins/define-plugin/
+            new webpack.DefinePlugin({
+
+                __DEV__: dev,
+                SERVER: side === 'server',
+                BUILD_DATE: JSON.stringify(dayjs().format('YY.MM.DD-HH.mm')),
+
+                CORE_PATH: JSON.stringify(cli.paths.core.root),
+                APP_PATH: JSON.stringify(cli.paths.app.root),
+                APP_NAME: JSON.stringify(cli.identity.web.title),
+
+            }),
+
+            new PluginIndexage(side === 'client' ? {
+                'icones-svg': new IconesSvg,
+            } : {
+                //'injection-dependances': new InjectDeps,
+            }),
+
+            ...(cli.args.analyze === side ? [
+
+                new BundleAnalyzerPlugin({
+                    defaultSizes: 'stat',
+                    openAnalyzer: false
+                }),
+
+            ] : []),
+
+
+
+            ...(dev ? [
+
+                // HMR
+                //new webpack.HotModuleReplacementPlugin()
+
+            ] : []),
+
+        ],
+
+        resolve: {
+
+            // Empêche le remplatcement des chemins vers les liens symboliques par leur vrai chemin
+            // Permet de conserver le chemin des packages enregistrés via npm link
+            // Equivalent tsconfig: preserveSymlinks: true
+            symlinks: false,
+
+            /*modules: [
+                cli.paths.core.root + '/node_modules',
+                cli.paths.app.root + '/node_modules',
+            ]*/
+        },
+
+        // Turn off performance processing because we utilize
+        // our own hints via the FileSizeReporter
+        performance: false,
+
+        // Don't attempt to continue if there are any errors.
+        bail: !dev,
+
+        // When true, Can cause troubles on re-compiling the client side
+        // "webpack" The "path" argument must be of type string. Received undefined
+        // https://github.com/webpack/webpack/issues/12616
+        // Update: Hum it's fixed, just had to update webpack deps
+        cache: dev,
+
+        profile: true,
+
+        // Pour bundle-stats
+        // https://github.com/relative-ci/bundle-stats/tree/master/packages/cli#webpack-configuration
+        stats: {
+            cached: dev,
+            cachedAssets: dev,
+            chunks: dev,
+            chunkModules: dev,
+            colors: true,
+            hash: dev,
+            modules: dev,
+            reasons: dev,
+            timings: true,
+            version: dev,
+            errorDetails: true
+        },
+
+    }
+
+    return config;
+
+}

package/src/compiler/common/plugins/indexage/_utils/Stringify.ts

@@ -0,0 +1,72 @@
+const placeholder: string = '____PLACEHOLDER____';
+const balises = {
+    fonction: '[fonction]',
+    methode: '[methode]'
+}
+
+const regRemplacements = new RegExp('("([^"]+)": )?"' + placeholder + '"', 'g');
+
+// Permet de transformer un objet en chaine json sans niquer les fonctions
+export default ( obj: object, fonctions: string[] = [] ): string => {
+
+    var fns: [string, string][] = [];
+
+    // Remplace les fonctions par un placeholder et tranforme en json
+    var json = JSON.stringify(obj, (key: string, value: any): string => {
+
+        const func: boolean = typeof value === 'function';
+        const ref_fonction: boolean = typeof value === 'string' && value.startsWith( balises.fonction );
+        const ref_methode: boolean = typeof value === 'string' && value.startsWith( balises.methode );
+
+        if (fonctions.includes(key) || func || ref_fonction || ref_methode) {
+
+            if (func)
+                value = value.toString();
+            else if (ref_fonction)
+                value = value.substring( balises.fonction.length );
+            else if (ref_methode)
+                value = value.substring( balises.methode.length );
+
+            fns.push([ value, ref_methode ? 'methode' : 'fonction' ]);
+
+            return placeholder;
+        }
+
+        return value;
+    }, 4);
+
+    // Remplace les placeholders par la fonction brute sans les guillemets
+    json = json.replace(regRemplacements, (match: string, contnom: string, nom: string): string => {
+        const func = fns.shift();
+        if (Array.isArray(func)) {
+
+            const [ fonction, type ] = func;
+
+            // La fonction est dans un tableau
+            if (nom === undefined)
+                return fonction;
+            else
+                return type === 'methode'
+                    // nom() { ... }
+                    ? nom + fonction
+                    // "nom": () => { ... }
+                    : '"'+ nom +'": ' + fonction;
+
+            return fonction ? fonction : '';
+
+        } else
+            return '';
+    });
+
+    // retire les quotes
+    json = json.replace(/\"([a-zA-Z]+)\"\:/gm, '$1:');
+
+    // Correction pour les méthodes de classe
+    // Remplace <nom>: <args> => { par <nom><args> {
+    json = json.replace(
+        /([a-zA-Z]+)\:\s*(\([a-zA-Z\,\s]*\))\s*\=\>\s*\{/gmi,
+        '$1$2 {'
+    );
+
+    return json;
+};

package/src/compiler/common/plugins/indexage/_utils/annotations.ts

@@ -0,0 +1,88 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+import fs from 'fs-extra';
+
+/*----------------------------------
+- TYPE
+----------------------------------*/
+type TDonnees = {[cle: string]: string | number};
+
+/*----------------------------------
+- FONCTION
+----------------------------------*/
+export default function lireAnnotations<TRetour = TDonnees>( fichier: string ): TRetour | undefined {
+
+    let annotations: TRetour = {} as TRetour;
+    let lectureAnnotations: boolean = false;
+
+    // Lecture de chaque ligne
+    const lignes = fs.readFileSync(fichier, 'utf-8').split('\n');
+    for (let ligne of lignes) {
+
+        // Debut des annotations
+        if (ligne === "/* ~~~~~~~~~~~~~~~~") {
+
+            lectureAnnotations = true;
+
+        // Fin des anotations
+        } else if (ligne === "~~~~~~~~~~~~~~~~ */") {
+
+            return annotations;
+
+        // Lecture des annotations
+        } else if (lectureAnnotations) {
+
+            // Retire le "* " au debut de la ligne
+            ligne = ligne.substring(2).trim();
+            // Ligne vide
+            if (ligne.length === 0)
+                continue;
+
+            // Niveau indentation
+            //const indentation = ligne.match(/^( )*/)
+            //const indentLevel = indentation === null ? 0 : indentation[0].length;
+            
+            // cle: valeur
+            if (ligne.includes(': ')) {
+
+                // Décomposition clé / valeur
+                let [cle, valeur] = ligne.split(': ') as [string, any];
+                cle = cle.trim().toLowerCase();
+
+                // retire le commentaire
+                const poscommentaire = valeur.indexOf(' //')
+                if (poscommentaire !== -1)
+                    valeur = valeur.substring(0, poscommentaire);
+                valeur = valeur.trim();
+
+                // Met en minuscules
+                if (cle) {
+
+                    // Correction type valeur
+                    if (valeur === 'true')
+                        valeur = true;
+                    else if (valeur === 'false')
+                        valeur = false;
+                    else if (!isNaN(Number(valeur)))
+                        valeur = parseFloat(valeur);
+
+                    // Référencement
+                    if (annotations[cle] === undefined)
+                        annotations[cle] = valeur;
+                    // Valeur déjà existante, regroupement dans un tableau
+                    else if (!Array.isArray(annotations[cle]))
+                        annotations[cle] = [annotations[cle], valeur];
+                    // Déjà en tableau, ajout élement
+                    else
+                        annotations[cle] = [...annotations[cle], valeur];
+
+                }
+
+            }
+        }
+
+    }
+
+    return undefined;
+}

package/src/compiler/common/plugins/indexage/_utils/iterateur.ts

@@ -0,0 +1,52 @@
+const path = require('path')
+const fs = require('fs')
+
+export default function iterateur(
+    dir: string,
+    func: (fichier: string, ext: string, cheminRelatif: string, dossier: string) => void,
+    extensions: string[] = [],
+    blacklist: string[] = [],
+    func_sinon?: (fichier: string) => void,
+    dir_root?: string
+) {
+
+    if (dir_root === undefined)
+        dir_root = dir;
+
+    // Lecture du contenu du dossier
+    const elements = fs.readdirSync(dir);
+    for (const file of elements) {
+
+        const file_relatif = dir + '/' + file;
+
+        // Pas dans la blacklist
+        if ((!blacklist || !blacklist.includes( file ))) {
+
+            // Récup chemin complet
+            const file_complet = path.resolve(dir, file);
+
+            // Extension sans le point
+            const ext = path.extname( file ).substring(1);
+
+            // Recup infos element
+            const stat = fs.statSync(file_complet);
+
+            // Dossier = recursion
+            if (stat && stat.isDirectory())
+
+                iterateur( file_relatif, func, extensions, blacklist, func_sinon, dir_root );
+
+            else if (extensions.includes( ext )) {
+
+                let chemin = file_relatif.substring(dir_root.length + 1, file_relatif.length - ext.length - 1)
+                if (chemin.endsWith('/index'))
+                    chemin = chemin.substring(0, chemin.length - 6);
+
+                func( file_relatif, ext, chemin, dir );
+
+            }
+
+        } else if (func_sinon)
+            func_sinon( file_relatif );
+    };
+}