proteum 1.0.0-1 → 1.0.0

package/vscode/copyimportationpath/package.json

@@ -0,0 +1,86 @@
+{
+	"name": "copyimportationpath",
+	"displayName": "CopyImportationPath",
+	"description": "",
+	"version": "0.0.1",
+	"engines": {
+		"vscode": "^1.57.0"
+	},
+	"categories": [
+		"Other"
+	],
+	"activationEvents": [
+		"onStartupFinished",
+		"onCommand:copyimportationpath.copy",
+		"onCommand:copyimportationpath.copyStatement"
+	],
+	"main": "./out/extension.js",
+	"contributes": {
+		"commands": [
+			{
+				"command": "copyimportationpath.copy",
+				"title": "Copy Importation Path"
+			},
+			{
+				"command": "copyimportationpath.copyStatement",
+				"title": "Copy Importation Statement"
+			}
+		],
+		"menus": {
+			"editor/context": [
+				{
+					"when": "editorFocus",
+					"command": "copyimportationpath.copy"
+				},
+				{
+					"when": "editorFocus",
+					"command": "copyimportationpath.copyStatement"
+				}
+			],
+			"editor/title/context": [
+				{
+					"command": "copyimportationpath.copy"
+				},
+				{
+					"command": "copyimportationpath.copyStatement"
+				}
+			],
+			"explorer/context": [
+				{
+					"command": "copyimportationpath.copy"
+				},
+				{
+					"command": "copyimportationpath.copyStatement"
+				}
+			]
+		}
+	},
+	"scripts": {
+		"vscode:prepublish": "npm run compile",
+		"compile": "tsc -p ./",
+		"watch": "tsc -watch -p ./",
+		"pretest": "npm run compile && npm run lint",
+		"lint": "eslint src --ext ts",
+		"test": "node ./out/test/runTest.js"
+	},
+	"devDependencies": {
+		"@types/glob": "^7.1.3",
+		"@types/mocha": "^8.2.2",
+		"@types/node": "14.x",
+		"@types/vscode": "^1.57.0",
+		"@typescript-eslint/eslint-plugin": "^4.26.0",
+		"@typescript-eslint/parser": "^4.26.0",
+		"eslint": "^7.27.0",
+		"glob": "^7.1.7",
+		"mocha": "^8.4.0",
+		"typescript": "^4.3.2",
+		"vscode-test": "^1.5.2"
+	},
+	"dependencies": {
+		"json5": "^2.2.0",
+		"minimatch": "^3.0.4"
+	},
+	"__metadata": {
+		"installedTimestamp": 1644001431526
+	}
+}

package/vscode/copyimportationpath/src/extension.ts

@@ -0,0 +1,300 @@
+import * as vscode from 'vscode';
+const fs = require('fs');
+const json5 = require('json5')
+const path = require('path');
+var minimatch = require("minimatch")
+
+type TAlias = { alias: string, chemin: string, partiel: boolean }
+
+export function activate(context: vscode.ExtensionContext) {
+
+	const regEntete = /^\/\/\s+([a-z]+)\:\s+(.+)/i
+	const templates: {[nom: string]: { glob?: string, regex?: RegExp, content: string }} = {}
+
+	const dossierTemplates = path.join(context.extensionPath, '../..', 'templates');
+    if (!fs.existsSync( dossierTemplates )){
+        console.log("Template folder not existing:", dossierTemplates);
+        return;
+    }
+
+	//const dossierTemplates = workspace + '/../node_modules/@dopamyn/framework/templates';
+	fs.readdir(dossierTemplates, (err: Error, files: string[]) => {
+
+		console.log("Lecture de", dossierTemplates, files);
+
+		if (err) return console.error(err);
+
+		for (const file of files) {
+
+			const nom = file.substring(0, file.lastIndexOf('.'));
+
+			let content = fs.readFileSync(dossierTemplates + '/' + file, { encoding: 'utf-8' });
+			const entete = regEntete.exec(content);
+			if (!entete) {
+				console.error(file + `: Entete manquante ou au mauvais format.`);
+				continue;
+			}
+
+			console.log('Template', file, nom, entete[1], entete[2]);
+
+			// Retire l'entete de la template
+			content = content.substring( entete[0].length ).trim()
+			templates[ nom ] = { content }
+
+			if (entete[1] === 'Glob')
+				templates[nom].glob = entete[2]
+			else if (entete[1] === 'Regex')
+				templates[nom].regex = new RegExp(entete[2])
+			else
+				console.error(file + `: Entete inconnue: ` + entete[1]);
+
+		}
+
+		console.log(templates);
+		
+	});
+	
+	vscode.workspace.onDidCreateFiles(async (e) => {
+		for (const file of e.files) {
+
+			const importPath = await getImportPath(file.path)
+			const importName = getImportName(importPath, file.path);
+
+			console.log("Fichier créé:", file.path, importPath);
+		
+			// Remplacements
+			for (const nom in templates) {
+				const { glob, regex, content } = templates[nom]
+
+				let match: RegExpMatchArray | null | undefined;
+
+				if ((glob && minimatch( file.path, glob )) || (match = regex?.exec( file.path ))) {
+
+					const remplacements: {[cle: string]: string} = {
+						NAMELOWER: importName.toLowerCase(),
+						NAME: importName,
+						ABSPATH: importPath,
+						...(match?.groups || {})
+					}
+
+					console.log("Template:", nom, "Remplacements:", remplacements);
+					
+					fs.writeFileSync(file.path, content.replace( 
+						new RegExp( Object.keys(remplacements).join('|'), 'g' ),
+						(match: string) => remplacements[match]
+					));
+					break;
+
+				}
+
+			}
+		}
+	});
+
+
+
+
+
+
+
+
+
+
+
+	const readTsConfig = async (chemin: string, workspace: string): Promise<TAlias[]> => {
+
+		console.log('Lecture de ' + chemin);
+		const rawtsconfig = fs.readFileSync(chemin, { encoding: 'utf-8' })
+		const tsconfig = json5.parse(rawtsconfig);
+
+		const paths = tsconfig.compilerOptions?.paths;
+		if (paths !== undefined) {
+
+			// Les plus specifiques en premiers
+			let retour: TAlias[] = []
+			for (let alias in paths) {
+
+				let chemin = path.join(workspace, paths[alias][0])
+				const partiel = chemin.endsWith('*');
+				if (partiel) {
+
+					// Retire le * à la fin
+					chemin = chemin.substring(0, chemin.length - 1);
+					alias = alias.substring(0, alias.length - 1);
+
+				}
+
+				retour.push({
+					partiel,
+					alias,
+					chemin
+				});
+
+			}
+
+			retour.sort((a, b) => b.chemin.length - a.chemin.length);
+
+			return retour;
+
+		} else if (tsconfig.extends !== undefined)
+			return await readTsConfig(path.resolve(path.dirname(chemin), tsconfig.extends), workspace);
+		else
+			return [];
+	}
+
+	const removeExtensions = (fichier: string, extensions: string[]) => {
+
+		for (const extension of extensions) {
+
+			console.log(extension, fichier);
+
+			if (fichier.endsWith('.' + extension)) {
+				fichier = fichier.substring(0, fichier.length - extension.length - 1);
+				break;
+			}
+		}
+
+		if (fichier.endsWith('/index'))
+			fichier = fichier.substring(0, fichier.length - 6);
+
+		return fichier;
+	}
+
+	const getListeAlias = async () => {
+
+
+		if (!vscode.workspace.workspaceFolders?.length) {
+			console.error(`Impossible de récupérer le dossier du workspace actuel`);
+			return []
+		}
+		const workspace = vscode.workspace.workspaceFolders[0].uri.path;
+
+		const tsconfigs = await vscode.workspace.findFiles('tsconfig.json');
+		if (tsconfigs.length === 0)
+			return []
+
+		return await readTsConfig(tsconfigs[0].path, workspace);
+	}
+
+	const getImportPath = async (fichier: string) => {
+
+		const listeAlias = await getListeAlias();
+
+		console.log('fichier =', fichier);
+
+		console.log('listeAlias =', listeAlias);
+
+		for (const alias of listeAlias) {
+
+			// Remplacement prefixe
+			if (alias.partiel) {
+
+				if (fichier.startsWith(alias.chemin)) {
+					fichier = alias.alias + fichier.substring(alias.chemin.length)
+					break;
+				}
+
+				// Remplacement complet
+			} else {
+
+				if (fichier === alias.chemin) {
+					fichier = alias.alias
+					break;
+				}
+
+			}
+
+		}
+
+		// Vire l'extension
+		fichier = removeExtensions(fichier, ['tsx', 'ts', 'js', 'jsx']);
+
+		return fichier;
+	}
+
+	const findImportPath = async (selectedFile: any) => {
+
+		let fichier: string;
+		if (selectedFile)
+			fichier = selectedFile.path;
+		else {
+			if (!vscode.window.activeTextEditor)
+				return console.error(`Aucun editeur actif`);
+			fichier = vscode.window.activeTextEditor.document.uri.path;
+		}
+
+		return await getImportPath(fichier);
+	}
+
+	const getImportName = (importPath: string, originalPath: string) => {
+
+		const content = fs.readFileSync(originalPath, { encoding: 'utf-8' });
+		const exportdefault = /export default\s+(function|class|new)\s+([a-zA-Z]+)/.exec(content);
+
+		let nomModule: string;
+		if (exportdefault) {
+			nomModule = exportdefault[2];
+		} else {
+			const posSlash = importPath.lastIndexOf('/');
+			nomModule = importPath.substring(posSlash === -1 ? 0 : posSlash + 1);
+			nomModule = nomModule[0].toUpperCase() + nomModule.substring(1);
+		}
+
+		return nomModule;
+	}
+
+	const copier = (txt: string) => {
+
+		console.log(txt);
+
+		vscode.env.clipboard.writeText(txt);
+
+		//vscode.window.showInformationMessage('Copied ' + txt);
+	}
+
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand('copyimportationpath.copy', async (selected) => {
+
+			try {
+
+				const fichier = await findImportPath(selected);
+				if (fichier)
+					copier(fichier);
+				
+			} catch (error) {
+
+				vscode.window.showErrorMessage( error.toString() );
+
+				console.error(error);
+				
+			}
+
+		}),
+
+		vscode.commands.registerCommand('copyimportationpath.copyStatement', async (selected) => {
+
+			try {
+
+				const importPath = await findImportPath(selected);
+				if (importPath) {
+
+					const importName = getImportName(importPath, selected.path);
+
+					copier(`import ${importName} from '${importPath}';`);
+
+				}
+
+			} catch (error) {
+
+				vscode.window.showErrorMessage(error.toString());
+
+				console.error(error);
+
+			}
+
+		})
+	);
+}
+
+export function deactivate() {}

package/vscode/copyimportationpath/tsconfig.json

@@ -0,0 +1,22 @@
+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"target": "es6",
+		"outDir": "out",
+		"lib": [
+			"es6"
+		],
+		"sourceMap": true,
+		"rootDir": "src",
+		"strict": true   /* enable all strict type-checking options */
+		/* Additional Checks */
+		// "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
+		// "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
+		// "noUnusedParameters": true,  /* Report errors on unused parameters. */
+	},
+	"exclude": [
+		"node_modules",
+		".vscode-test",
+		"templates"
+	]
+}

package/vscode/copyimportationpath/vsc-extension-quickstart.md

@@ -0,0 +1,42 @@
+# Welcome to your VS Code Extension
+
+## What's in the folder
+
+* This folder contains all of the files necessary for your extension.
+* `package.json` - this is the manifest file in which you declare your extension and command.
+  * The sample plugin registers a command and defines its title and command name. With this information VS Code can show the command in the command palette. It doesn’t yet need to load the plugin.
+* `src/extension.ts` - this is the main file where you will provide the implementation of your command.
+  * The file exports one function, `activate`, which is called the very first time your extension is activated (in this case by executing the command). Inside the `activate` function we call `registerCommand`.
+  * We pass the function containing the implementation of the command as the second parameter to `registerCommand`.
+
+## Get up and running straight away
+
+* Press `F5` to open a new window with your extension loaded.
+* Run your command from the command palette by pressing (`Ctrl+Shift+P` or `Cmd+Shift+P` on Mac) and typing `Hello World`.
+* Set breakpoints in your code inside `src/extension.ts` to debug your extension.
+* Find output from your extension in the debug console.
+
+## Make changes
+
+* You can relaunch the extension from the debug toolbar after changing code in `src/extension.ts`.
+* You can also reload (`Ctrl+R` or `Cmd+R` on Mac) the VS Code window with your extension to load your changes.
+
+
+## Explore the API
+
+* You can open the full set of our API when you open the file `node_modules/@types/vscode/index.d.ts`.
+
+## Run tests
+
+* Open the debug viewlet (`Ctrl+Shift+D` or `Cmd+Shift+D` on Mac) and from the launch configuration dropdown pick `Extension Tests`.
+* Press `F5` to run the tests in a new window with your extension loaded.
+* See the output of the test result in the debug console.
+* Make changes to `src/test/suite/extension.test.ts` or create new test files inside the `test/suite` folder.
+  * The provided test runner will only consider files matching the name pattern `**.test.ts`.
+  * You can create folders inside the `test` folder to structure your tests any way you want.
+
+## Go further
+
+ * Reduce the extension size and improve the startup time by [bundling your extension](https://code.visualstudio.com/api/working-with-extensions/bundling-extension).
+ * [Publish your extension](https://code.visualstudio.com/api/working-with-extensions/publishing-extension) on the VSCode extension marketplace.
+ * Automate builds by setting up [Continuous Integration](https://code.visualstudio.com/api/working-with-extensions/continuous-integration).

package/cli/app/config.ts

@@ -1,54 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-/*
-    NOTE: This is a copy of core/sever/app/config
-    We can't import core deps here because it will cause the following error:
-        "Can't use import when not a module"
-    It will be possible to import core files when the CLI will be compiled as one output file with tsc
-    And for that, we need to fix the TS errors for the CLI
-*/
-
-// Npm
-import fs from 'fs-extra';
-import yaml from 'yaml';
-
-// Types
-import type { TEnvConfig } from '../../server/app/container/config';
-
-/*----------------------------------
-- LOADE
-----------------------------------*/
-export default class ConfigParser {
-
-    public constructor(
-        public appDir: string,
-        public envName?: string
-    ) {
-
-    }
-
-    private loadYaml( filepath: string ) {
-        console.info(`Loading config ${filepath}`);
-        const rawConfig = fs.readFileSync(filepath, 'utf-8');
-        return yaml.parse(rawConfig);
-    }
-
-    public env(): TEnvConfig {
-        // We assume that when we run 5htp dev, we're in local
-        // Otherwise, we're in production environment (docker)
-        console.log("[app] Using environment:", process.env.NODE_ENV);
-        const envFileName = this.appDir + '/env.yaml';
-        const envFile = this.loadYaml( envFileName );
-        return {
-            ...envFile,
-            version: 'CLI'
-        }
-    }
-
-    public identity() {
-        const identityFile = this.appDir + '/identity.yaml';
-        return this.loadYaml( identityFile );
-    }
-}

package/cli/app/index.ts

@@ -1,195 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// npm
-import path from 'path';
-import TsAlias from 'ts-alias';
-import fs from 'fs-extra';
-
-// Cre
-import cli from '..';
-
-// Specific
-import ConfigParser from './config';
-import type { TEnvConfig } from '../../server/app/container/config';
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
-
-export type TAppSide = 'server' | 'client'
-
-type TServiceSetup = {
-    id: string,
-    name: string,
-    config: {},
-    subservices: TServiceSubservices,
-    type: 'service.setup'
-}
-
-type TServiceRef = {
-    refTo: string,
-    type: 'service.ref'
-}
-
-type TServiceSubservices = {
-    [key: string]: TServiceSetup | TServiceRef
-}
-
-/*----------------------------------
-- SERVICE
-----------------------------------*/
-export class App {
-
-    // config
-    // WARNING: High level config files (env and services) shouldn't be loaded from the CLI
-    //  The CLI will be run on CircleCI, and no env file should be sent to this service
-    public identity: Config.Identity;
-
-    public env: TEnvConfig;
-
-    public packageJson: {[key: string]: any};
-
-    public buildId: number = Date.now();
-
-    public paths = {
-
-        root: cli.paths.appRoot,
-        bin: path.join( cli.paths.appRoot, 'bin'),
-        data: path.join( cli.paths.appRoot, 'var', 'data'),
-        public: path.join( cli.paths.appRoot, 'public'),
-        pages: path.join( cli.paths.appRoot, 'client', 'pages'),
-        cache: path.join( cli.paths.appRoot, '.cache'),
-
-        client: {
-            generated: path.join( cli.paths.appRoot, 'client', '.generated')
-        },
-        server: {
-            generated: path.join( cli.paths.appRoot, 'server', '.generated'),
-            configs: path.join( cli.paths.appRoot, 'server', 'app')
-        },
-        common: {
-            generated: path.join( cli.paths.appRoot, 'common', '.generated')
-        },
-        
-        withAlias: (filename: string, side: TAppSide) => 
-            this.aliases[side].apply(filename),
-
-        withoutAlias: (filename: string, side: TAppSide) => 
-            this.aliases[side].realpath(filename),
-    }
-
-    public containerServices = [
-        //'Services',
-        'Environment',
-        'Identity',
-        /*'Application',
-        'Path',
-        'Event'*/
-    ]
-
-    public constructor() {
-        
-        cli.debug && console.log(`[cli] Loading app config ...`);
-        const configParser = new ConfigParser( cli.paths.appRoot );
-        this.identity = configParser.identity();
-        this.env = configParser.env();
-        this.packageJson = this.loadPkg();
-        
-    }
-
-    /*----------------------------------
-    - ALIAS
-    ----------------------------------*/
-
-    public aliases = {
-        client: new TsAlias({
-            rootDir: this.paths.root + '/client',
-            modulesDir: [ 
-                cli.paths.appRoot + '/node_modules',  
-                cli.paths.coreRoot + '/node_modules'
-            ],
-            debug: false
-        }),
-        server: new TsAlias({
-            rootDir: this.paths.root + '/server',
-            modulesDir: [ 
-                cli.paths.appRoot + '/node_modules',  
-                cli.paths.coreRoot + '/node_modules'
-            ],
-            debug: false
-        }),
-    }
-
-    private loadPkg() {
-        return fs.readJSONSync(this.paths.root + '/package.json');
-    }
-
-    /*----------------------------------
-    - WARMUP (Services awareness)
-    ----------------------------------*/
-
-    public registered = {}
-
-    public use( referenceName: string ): TServiceRef {
-
-        // We don't check because all service are not regstered when we register subservices
-        /*if (this.registered[referenceName] === undefined) {
-            throw new Error(`Service ${referenceName} is not registered`);
-        }*/
-
-        return {
-            refTo: referenceName,
-            type: 'service.ref'
-        }
-    }
-
-    public setup(...args: [
-        // { user: app.setup('Core/User') }
-        servicePath: string,
-        serviceConfig?: {},
-    ] | [
-        // app.setup('User', 'Core/User')
-        serviceName: string, 
-        servicePath: string,
-        serviceConfig?: {},
-    ]): TServiceSetup {
-
-        // Registration to app root
-        if (typeof args[1] === 'string') {
-            
-            const [name, id, config] = args;
-
-            const service = { id, name, config, type: 'service.setup' } as TServiceSetup
-
-            this.registered[name] = service;
-
-            return service;
-
-        // Scoped to a parent service
-        } else {
-
-            const [id, config] = args;
-
-            const service = { id, config, type: 'service.setup' } as TServiceSetup
-
-            return service;
-        }
-    }
-
-    public async warmup() {
-
-        // Require all config files in @/server/config
-        const configDir = path.resolve(cli.paths.appRoot, 'server', 'config');
-        const configFiles = fs.readdirSync(configDir);
-        for (const configFile of configFiles) {
-            console.log("Loading config file:", configFile);
-            require( path.resolve(configDir, configFile) );
-        }
-    }
-}
-
-export const app = new App
-
-export default app