5htp 0.2.3 → 0.3.0

package/src/compiler/common/babel/plugins/models.old.ts

@@ -1,241 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Npm
-import * as types from '@babel/types'
-import type { PluginObj, NodePath } from '@babel/core';
-import generate from '@babel/generator';
-
-// Core
-import type { TAppSide } from '@cli/index';
-
-/*----------------------------------
-- WEBPACK RULE
-----------------------------------*/
-
-type TOptions = {
-    side: TAppSide
-}
-
-module.exports = (options: TOptions) => ({
-    test: "**/server/models/**/*.ts",
-    plugins: [
-        [Plugin, options]
-    ]
-})
-
-module.exports.Plugin = Plugin;
-
-const debug = true;
-
-const metasKey = 'metadata';
-
-/*----------------------------------
-- PLUGIN
-----------------------------------*/
-function Plugin(babel, {  }: TOptions) {
-
-    const t = babel.types as typeof types;
-
-    const plugin: PluginObj<{ filename: string }> = {
-        pre(state) {
-
-            this.filename = state.opts.filename as string;
-
-        },
-        visitor: {
-            Program(path) {
-
-                const filename = this.filename;
-
-                // Lorsque les visiteurs sont déclarés à la racine du plugin,
-                //    Impossible d'obtenir les ast des décorateurs car ils ont déjà été compilés ...
-                //    Pourquoi cela fonctionne en passant par Program.traverse ?
-                path.traverse({
-                    Decorator(path) {
-
-                        injectMetadatas(path, filename, t);
-
-                    },
-                });
-                
-
-            }
-           
-        }
-    };
-
-    return plugin;
-}
-
-/*----------------------------------
-- EXTRACTION
-----------------------------------*/
-function injectMetadatas( path: NodePath<types.Decorator>, filename: string, t: typeof types ) {
-
-    // @Table( <database>, <table>, <options?> )
-    const expression = path.node.expression;
-    if (!(
-        expression.type === 'CallExpression'
-        &&
-        expression.callee.type === 'Identifier'
-        &&
-        expression.callee.name === 'Table'
-        &&
-        expression.arguments.length >= 2
-    ))
-        return;
-
-    // Class
-    const classe = path.parent;
-    if (classe.type !== 'ClassDeclaration')
-        return;
-
-    debug && console.log(`Processing class ${classe.id.name}`);
-
-    // Only process if metadata are not already defined
-    let [database, table, options] = expression.arguments;
-    if (options !== undefined) {
-
-        if (options.type !== 'ObjectExpression')
-            throw new Error(`Error in ${filename}: The 3rd argument of @Table must be an object expression.`);
-
-        const hasMetas = options.properties.some(p =>
-            p.type === 'ObjectProperty'
-            &&
-            p.key.type === 'Identifier'
-            &&
-            p.key.name === metasKey
-        );
-
-        if (hasMetas) {
-            debug && console.log(`Metadata already provides for class ${classe.id.name} (${filename})`);
-            return;
-        }
-    }
-
-    // Extract metadata
-    const attributes = extractMetadata(classe, t);
-    //debug && console.log( generate(attributes).code );
-    const metasProperty = t.objectProperty(
-        t.identifier(metasKey),
-        t.objectExpression(attributes)
-    )
-
-    // Insert metas in options
-    if (options === undefined)
-        options = t.objectExpression([metasProperty]);
-    else
-        options = t.objectExpression([...options.properties, metasProperty]);
-
-    // Update decorator
-    path.replaceWith(t.decorator(
-        t.callExpression(t.identifier('Table'), [
-            database,
-            table,
-            options
-        ])
-    ));
-}
-
-function extractMetadata(classe: types.ClassDeclaration, t: typeof types) {
-
-    const attributes: types.ObjectProperty[] = [];
-
-    // Lecture des propriétés et méthodes de la classe
-    for (const prop of classe.body.body) {
-
-        if (!(
-            // non-statique
-            !prop.static
-            &&
-            (
-                // Propriété simple
-                prop.type === 'ClassProperty'
-                || 
-                // Getter
-                (prop.type === 'ClassMethod' && prop.kind === 'get')
-            )
-            &&
-            // Publique
-            prop.accessibility === 'public'
-            &&
-            prop.key.type === 'Identifier'
-        ))
-            continue;
-
-        const nomProp = prop.key.name;
-
-        // Détermine si la propriété est exposée à l'api
-        // = possède le décorateur @API()
-        const exposeToAPI = prop.decorators && prop.decorators.some((decorateur) =>
-            decorateur.expression.type === 'CallExpression'
-            &&
-            decorateur.expression.callee.type === 'Identifier'
-            &&
-            decorateur.expression.callee.name === 'API'
-        );
-
-        if (!exposeToAPI) continue;
-
-        let type: any;
-        if (prop.type === 'ClassProperty')
-            type = prop.typeAnnotation;
-        else
-            type = prop.returnType;
-
-        // Verif si type spécifié
-        if (!type)
-            throw new Error(`Unable to extract type of ${classe.id.name}.${prop.key.name}.`);
-
-        // Sérialisation du type
-        const typeString = generate(type.typeAnnotation).code;
-
-        debug && console.log( classe.id.name + '.' + nomProp + ': ' + typeString );
-
-        // Sérialisation valeur defaut
-        const defaut = prop.type === 'ClassProperty' && prop.value && ('value' in prop.value)
-            ? prop.value
-            : t.identifier('undefined')
-
-        attributes.push(
-            t.objectProperty( t.identifier(nomProp), t.objectExpression([
-
-                t.objectProperty( 
-                    t.identifier('nom'), 
-                    t.stringLiteral(nomProp)
-                ),
-
-                t.objectProperty( 
-                    t.identifier('nomComplet'), 
-                    t.stringLiteral(prop.optional ? nomProp + '?' : nomProp)
-                ),
-
-                t.objectProperty( 
-                    t.identifier('type'), 
-                    t.stringLiteral(typeString)
-                ),
-
-                t.objectProperty( 
-                    t.identifier('optionnel'), 
-                    t.booleanLiteral(prop.optional === true)
-                ),
-
-                t.objectProperty(
-                    t.identifier('api'),
-                    t.booleanLiteral(exposeToAPI)
-                ),
-
-                t.objectProperty(
-                    t.identifier('defaut'),
-                    defaut
-                ),
-                
-            ]))
-        );
-    }
-
-    return attributes;
-
-}

package/src/compiler/common/babel/routes/routes_old.ts

@@ -1,152 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Npm
-import * as types from '@babel/types'
-import type { PluginObj, NodePath } from '@babel/core';
-import generate from '@babel/generator';
-
-// Core
-import cli from '@cli';
-import App, { TAppSide } from '../../../../app';
-
-/*----------------------------------
-- WEBPACK RULE
-----------------------------------*/
-
-type TOptions = {
-    side: TAppSide
-}
-
-module.exports = (options: TOptions) => ({
-    test: "**/client/pages/**/*.tsx",
-    plugins: [
-        [Plugin, options]
-    ]
-})
-
-const debug = false;
-
-/*----------------------------------
-- PLUGIN
-----------------------------------*/
-function Plugin(babel, { side }: TOptions) {
-
-    const app = new App();
-
-    const t = babel.types as typeof types;
-    let program: NodePath<types.Program>;
-
-    const plugin: PluginObj<{ 
-        filename: string
-    }> = {
-        pre(state) {
-
-            this.filename = state.opts.filename as string;
-
-        },
-        visitor: {
-
-            Program(path) {
-                program = path;
-            },
-
-            CallExpression(path) {
-                
-                // route.xxx( <PATH>, ... )
-                if (!(
-                    path.node.callee.type === 'MemberExpression'
-                    &&
-                    path.node.callee.object.type === "Identifier"
-                    &&
-                    path.node.callee.object.name === "route"
-                    &&
-                    path.node.arguments.length >= 2
-                ))
-                    return;
-
-                const [routePath, ...routeArgs] = path.node.arguments;
-                debug && console.log(`[routes]`, this.filename, ...routeArgs.map(n => n.type));
-                    
-                // Inject chunk id in options (2nd arg)
-                const status = addChunkId(routeArgs, this.filename);
-                if (status === 'ALREADY_PROCESSED')
-                    return;
-
-                // Transform 2nd arg of renderer to a useContext spread
-                addRendererContext(routeArgs, this.filename);
-
-                const replacement = t.callExpression( path.node.callee, [ routePath, ...routeArgs ]);
-                debug && console.log( generate(replacement).code );
-
-                path.replaceWith( replacement );
-
-                // Force export default
-                // NOTE: now done by app-import.ts
-                /*if (path.parent.type === 'ExportDefaultDeclaration')
-                    path.replaceWith( replacement );
-                else
-                    path.parentPath.replaceWith(
-                        t.exportDefaultDeclaration( replacement )
-                    )*/
-                
-            }
-           
-        }
-    };
-
-    function addRendererContext( 
-        routeArgs: types.CallExpression["arguments"],
-        filename: string
-    ) {
-
-        // ( <data>, { response, api }) => ....
-        const renderer = routeArgs[ routeArgs.length - 1 ];
-        if (!(
-            renderer.type === 'ArrowFunctionExpression' 
-            && 
-            renderer.params.length > 1
-        ))
-            return;
-
-        // Remove 2nd arg (renderer = react component, so only 1 arg for props)
-        const declaration = renderer.params.pop() as types.ArrowFunctionExpression["params"][number];
-        // const <param2> = useContext();
-        const ctxDeclaration = t.variableDeclaration('const', [t.variableDeclarator(
-            declaration,
-            t.callExpression(t.identifier('useContext'), [])
-        )])
-
-        // Add Declaration
-        switch (renderer.body.type) {
-            case 'BlockStatement':
-                renderer.body.body.unshift(ctxDeclaration);
-                break;
-            // TODO: Si type === JSXElement, remplacer par BlockStatement (ctxDeclaration + return JSX)
-            /*case 'BlockStatement':
-                renderer.re
-                break;*/
-            default:
-                throw new Error(`Unknown body type for the renderer: ${renderer.body.type}`);
-        }
-
-        // Add usecontext import if it doesn't exists
-        if (program.scope.bindings["useContext"] === undefined) {
-
-            debug && console.log(`[routes]`, filename, `Adding useContext import from @context`);
-
-            program.unshiftContainer(
-                'body',
-                t.importDeclaration(
-                    [t.importDefaultSpecifier(t.identifier('useContext'))],
-                    t.stringLiteral('@/client/context')
-                )
-            );
-        }
-        
-
-    }
-
-    return plugin;
-}

package/src/compiler/common/utils/fixNpmLink.ts

@@ -1,46 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Npm
-import path from 'path';
-import fs from 'fs-extra';
-
-// App
-import type App from '../../../app';
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
-
-/*----------------------------------
-- UTTILS
-----------------------------------*/
-export const fixNpmLinkIssues = ( app: App ) => {
-
-    const corePath = path.join(app.paths.root, '/node_modules/5htp-core');
-    if (!fs.lstatSync( corePath ).isSymbolicLink())
-        return console.info("Not fixing npm issue because 5htp-core wasn't installed with npm link.");
-
-    console.info(`Fix NPM link issues ...`);
-
-    const appModules = path.join(app.paths.root, 'node_modules');
-    const coreModules = path.join(corePath, 'node_modules');
-
-    // When the 5htp package is installed from npm link,
-    // Modules are installed locally and not glbally as with with the 5htp package from NPM.
-    // So we need to symbilnk the http-core node_modules in one of the parents of server.js.
-    // It avoids errors like: "Error: Cannot find module 'intl'"
-    fs.symlinkSync( coreModules, path.join(app.paths.bin, 'node_modules') );
-
-    // Same problem: when 5htp-core is installed via npm link, 
-    // Typescript doesn't detect React and shows mission JSX errors
-    const preactCoreModule = path.join(coreModules, 'preact');
-    const preactAppModule = path.join(appModules, 'preact');
-    const reactAppModule = path.join(appModules, 'react');
-
-    if (!fs.existsSync( preactAppModule ))
-        fs.symlinkSync( preactCoreModule, preactAppModule );
-    if (!fs.existsSync( reactAppModule ))
-        fs.symlinkSync( path.join(preactCoreModule, 'compat'), reactAppModule );
-}