lucy-cli 0.7.15 → 0.8.0

package/src/gulp/checks.ts

@@ -3,7 +3,8 @@ import glob from 'glob';
 import * as path from 'path';
 import gulp from 'gulp';
 import ts from 'gulp-typescript';
-import { blue, green, magenta, red, yellow } from '../index.js';
+import { blue, green, magenta, orange, red, yellow } from '../index.js';
+import { TaskOptions } from '../Gulpfile.js';
 
 /**
  *  Extracts a match from a file
@@ -118,33 +119,36 @@ export async function checkPages(fail: boolean, force: boolean) {
 	});
 }
 
-export function checkTs() {
-    const tsProject = ts.createProject('./lib/tsconfig.json', { noEmit: true });
-    return () => {
-        return 	gulp.src(['lib/typescript/**/*.ts', '!lib/typescript/types/**/*.ts'], { cwd: 'typescript' })
-        .pipe(tsProject(ts.reporter.fullReporter()))
-        .on('error', function () {
-            console.log("💩" + red.underline.bold(' => Typescript error!'));
-            this.emit('end');
-        })
-        .on('end', function () {
-            console.log("🐶" + blue.underline(' => Typescriptcheck succeeded!'));
-        });
-    };
-}
+export function checkTs(options: TaskOptions) {
+    const folders = ['typescript'];
+    if (options.modulesSync){
+        for (const module of Object.keys(options.modulesSync)) {
+            folders.push(module);
+        }
+    }
+
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+		const tsProject = ts.createProject(`./${folder}/tsconfig.json`, { noEmit: true });
+
+        const taskName = `test-${folder}`; // Create a unique name for each task
+
+        const task = () =>
+            gulp.src([`${folder}/**/*.ts`, `!${folder}/types/**/*.ts`], { cwd: folder })
+				.pipe(tsProject(ts.reporter.fullReporter()))
+                .on('error', function () {
+                    console.log("💩" + red.underline.bold(` => Typescriptcheck for ${orange(folder)} failed!`));
+                    this.emit('end');
+                })
+                .on('end', function () {
+                    console.log("🐶" + blue.underline(` => Typescriptcheck for ${orange(folder)} succeeded!`));
+                });
 
-export function checkTsLib() {
-    const tsProject = ts.createProject('./lib/tsconfig.json', { noEmit: true });
+        // Register the task with Gulp
+        Object.defineProperty(task, 'name', { value: taskName }); // Set a unique name for debugging
+        return task;
+    });
 
-    return () => {
-        return 	gulp.src(['lib/typescript/**/*.ts', '!lib/typescript/types/**/*.ts'], { cwd: 'typescript' })
-        .pipe(tsProject(ts.reporter.fullReporter()))
-        .on('error', function () {
-            console.log("💩" + red.underline.bold(' => Typescript (LIB) error!'));
-            this.emit('end');
-        })
-        .on('end', function () {
-            console.log("🐶" + blue.underline(' => Typescript check (LIB) succeeded!'));
-        });
-    };
+    // Run all tasks in parallel
+    return gulp.parallel(...tasks);
 }

package/src/gulp/copy.ts

@@ -1,48 +1,47 @@
 import gulp from 'gulp';
 import chalk from 'chalk';
 import { TaskOptions } from '../Gulpfile';
-import { blue, red } from '../index.js';
+import { blue, orange, red } from '../index.js';
 
 export function copyFiles(options: TaskOptions) {
-    const { outputDir} = options;
-
-    return () => {
-        return gulp.src([
-			'typescript/**/*', 
-			'!typescript/*tsconfig.json', 
-			'!typescript/**/*.ts', 
-			'!typescript/**/*.tsx', 
-			'!typescript/types/**/**', 
-			'!typescript/__mocks__/**/**', 
-			'!typescript/styles/**',
-		])
-		.pipe(gulp.dest(outputDir))
-		.on('error', function () {
-			console.log("💩" + red.underline.bold(' => Copy of files failed!'));
-			this.emit('end');
-		})
-		.on('end', function() { console.log("🐶" + blue.underline(' => Copy of files succeeded!')); });
+    const folders = ['typescript'];
+    if (options.modulesSync){
+        for (const module of Object.keys(options.modulesSync)) {
+            folders.push(module);
+        }
     }
-}
 
-export function copyFilesLib(options: TaskOptions) {
-    const { outputDir} = options;
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+		const { outputDir} = options;
 
-    return () => {
-        return gulp.src([
-			'typescript/**/*', 
-			'!typescript/*tsconfig.json', 
-			'!typescript/**/*.ts', 
-			'!typescript/**/*.tsx', 
-			'!typescript/types/**/**', 
-			'!typescript/__mocks__/**/**', 
-			'!typescript/styles/**',
-		])
-		.pipe(gulp.dest(outputDir))
-		.on('error', function () {
-			console.log("💩" + red.underline.bold(' => Copy of files (LIB) failed!'));
-			this.emit('end');
-		})
-		.on('end', function() { console.log("🐶" + blue.underline(' => Copy of files (LIB) succeeded!')); });
-    }
-}
+
+        const taskName = `copy-${folder}`; // Create a unique name for each task
+
+        const task = () =>
+			gulp.src([
+				`${folder}/**/*`, 
+				`!${folder}/*tsconfig.json`, 
+				`!${folder}/**/*.ts`, 
+				`!${folder}/**/*.tsx`, 
+				`!${folder}/types/**/**`, 
+				`!${folder}/__mocks__/**/**`, 
+				`!${folder}/styles/**`,
+			])
+			.pipe(gulp.dest(outputDir))
+                .on('error', function () {
+                    console.log("💩" + red.underline.bold(` => Copy of files for ${orange(folder)} failed!`));
+                    this.emit('end');
+                })
+                .on('end', function () {
+                    console.log("🐶" + blue.underline(` => Copy of files for ${orange(folder)} succeeded!`));
+                });
+
+        // Register the task with Gulp
+        Object.defineProperty(task, 'name', { value: taskName }); // Set a unique name for debugging
+        return task;
+    });
+
+    // Run all tasks in parallel
+    return gulp.parallel(...tasks);
+}

package/src/gulp/helpers.ts

@@ -0,0 +1,9 @@
+
+import * as path from 'path';
+import * as fs from 'fs';
+
+export function getModulesSync(): Record<string, string> | undefined {
+    const absolutePath = path.resolve('./lucy.json');
+    const fileContent = fs.readFileSync(absolutePath, 'utf8') as any;
+    return JSON.parse(fileContent).modules;
+}

package/src/gulp/public.ts

@@ -3,62 +3,51 @@ import { createGulpEsbuild } from 'gulp-esbuild';
 
 import * as path from 'path';
 import { TaskOptions } from '../Gulpfile';
-import { blue, red } from '../index.js';
+import { blue, orange, red } from '../index.js';
 
 export function buildPublic(options: TaskOptions) {
+    const folders = ['typescript'];
+    if (options.modulesSync){
+        for (const module of Object.keys(options.modulesSync)) {
+            folders.push(module);
+        }
+    }
+
     const { outputDir, enableIncrementalBuild } = options;
     const gulpEsbuild = createGulpEsbuild({
         incremental: enableIncrementalBuild,
     });
 
-    return () => {
-        return gulp.src([
-            'typescript/public/**/*.ts',
-            'typescript/public/**/*.tsx',
-        ])
-        .pipe(gulpEsbuild({
-            bundle: false,
-            loader: {
-                '.tsx': 'tsx',
-            },
-        }))
-        .pipe(gulp.dest(path.join(outputDir, 'public')))
-        .on('error', function () {
-        console.log("💩" + red.underline.bold(' => Build of Public TS files failed!'));
-        this.emit('end');
-        })
-        .on('end', function () {
-        console.log("🐶" + blue.underline(' => Build of Public TS files succeeded!'));
-        });
-    };
-}
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+        const taskName = `build_Public-${folder}`; // Create a unique name for each task
 
-export function buildPublicLib(options: TaskOptions) {
-    const { outputDir, enableIncrementalBuild } = options;
-    const gulpEsbuild = createGulpEsbuild({
-        incremental: enableIncrementalBuild,
+        const task = () =>
+            gulp.src([
+                `${folder}/public/**/*.ts`,
+                `${folder}/public/**/*.tsx`,
+            ])
+            .pipe(gulpEsbuild({
+                bundle: false,
+                loader: {
+                    '.tsx': 'tsx',
+                },
+            }))
+            .pipe(gulp.dest(path.join(outputDir, 'public')))
+                .on('error', function () {
+                    console.log("💩" + red.underline.bold(` => Build of Public files for ${orange(folder)} failed!`));
+                    this.emit('end');
+                })
+                .on('end', function () {
+                    console.log("🐶" + blue.underline(` => Build of Public files for ${orange(folder)} succeeded!`));
+                });
+
+        // Register the task with Gulp
+        Object.defineProperty(task, 'name', { value: taskName }); // Set a unique name for debugging
+        return task;
     });
 
-    return () => {
-        return gulp.src([
-            'lib/public/**/*.ts',
-            'lib/public/**/*.tsx'
-        ])
-        .pipe(gulpEsbuild({
-            bundle: false,
-            loader: {
-                '.tsx': 'tsx',
-            },
-        }))
-        .pipe(gulp.dest(path.join(outputDir, 'public')))
-        .on('error', function () {
-        console.log("💩" + red.underline.bold(' => Build of Public (LIB) TS files failed!'));
-        this.emit('end');
-        })
-        .on('end', function () {
-        console.log("🐶" + blue.underline(' => Build of Public (LIB) TS files succeeded!'));
-        });
-    };
+    // Run all tasks in parallel
+    return gulp.parallel(...tasks);
 }
 
-

package/src/gulp/styles.ts

@@ -1,21 +1,40 @@
 import gulp from 'gulp';
 import chalk from 'chalk';
 import { TaskOptions } from '../Gulpfile';
-import { blue, red } from '../index.js';
+import { blue, orange, red } from '../index.js';
 
 export function compileScss(options: TaskOptions) {
+    const folders = ['typescript'];
+    // if (options.modulesSync){
+    //     for (const module of Object.keys(options.modulesSync)) {
+    //         folders.push(module);
+    //     }
+    // }
+
     const { sass, outputDir} = options;
 
-    return () => {
-        return 	gulp.src(['typescript/styles/global.scss'])
-		.pipe(sass().on('error', sass.logError))
-		.pipe(gulp.dest(`${outputDir}/styles`))
-        .on('error', function () {
-            console.log("💩" + red.underline.bold(' => Compiling of scss files failed!'));
-            this.emit('end');
-            })
-            .on('end', function () {
-            console.log("🐶" + blue.underline(' => Compiling of scss files succeeded!'));
-            });
-    };
+
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+        const taskName = `compile_sass-${folder}`; // Create a unique name for each task
+
+        const task = () =>
+            gulp.src(['typescript/styles/global.scss'])
+                .pipe(sass().on('error', sass.logError))
+                .pipe(gulp.dest(`${outputDir}/styles`))
+                .on('error', function () {
+                    console.log("💩" + red.underline.bold(` => Compiling of scss files for ${orange(folder)} failed!`));
+                    this.emit('end');
+                })
+                .on('end', function () {
+                    console.log("🐶" + blue.underline(` => Compiling of scss files for ${orange(folder)} succeeded!`));
+                });
+
+        // Register the task with Gulp
+        Object.defineProperty(task, 'name', { value: taskName }); // Set a unique name for debugging
+        return task;
+    });
+
+    // Run all tasks in parallel
+    return gulp.parallel(...tasks);
 }

package/src/gulp/templates.ts

@@ -1,44 +1,43 @@
 import gulp from 'gulp';
-import { File } from '../Gulpfile';
+import { File, TaskOptions } from '../Gulpfile';
 import exec from 'gulp-exec';
-import { blue, red } from '../index.js';
+import { blue, orange, red } from '../index.js';
 
-export function previewTemplates() {
-    const options = {
-        continueOnError: true,
-    };
-
-    return () => {
-        return gulp.src([
-            'typescript/backend/templates/**/*.tsx', 
-            'typescript/backend/templates/data/*.json', 
-            '!typescript/backend/templates/render.ts',
-        ])
-            .pipe(exec((file: File) => `npx ts-node-esm -T ${file.path}`, options))
-            .on('error', function () {
-                console.log("💩" + red.underline.bold(' => Render of Template failed!'));
-                this.emit('end');
-            })
-            .on('end', function() { console.log("🐶" + blue.underline(' => Render of Template succeeded!')); });
-        };
-}
-
-export function previewTemplatesLib() {
-    const options = {
-        continueOnError: true,
-    };
-
-    return () => {
-        return gulp.src([
-            'lib/backend/templates/**/*.tsx', 
-            'lib/backend/templates/data/*.json', 
-            '!lib/backend/templates/render.ts',
-        ])
-            .pipe(exec((file: File) => `npx ts-node-esm -T ${file.path}`, options))
-            .on('error', function () {
-                console.log("💩" + red.underline.bold(' => Render of Template (LIB) failed!'));
-                this.emit('end');
-            })
-            .on('end', function() { console.log("🐶" + blue.underline(' => Render of Template (LIB) succeeded!')); });
+export function previewTemplates(options: TaskOptions) {
+        const folders = ['typescript'];
+        if (options.modulesSync){
+            for (const module of Object.keys(options.modulesSync)) {
+                folders.push(module);
+            }
+        }
+        
+        const taskOpt = {
+            continueOnError: true,
         };
+    
+        // Create tasks for each folder
+        const tasks = folders.map((folder) => {
+            const taskName = `render_templates-${folder}`; // Create a unique name for each task
+            const task = () =>
+                gulp.src([
+                    `${folder}/backend/templates/**/*.tsx`, 
+                    `${folder}/backend/templates/data/*.json`, 
+                    `!${folder}/backend/templates/render.ts`,
+                ])
+                .pipe(exec((file: File) => `npx ts-node-esm -T ${file.path}`, taskOpt))
+                    .on('error', function () {
+                        console.log("💩" + red.underline.bold(` => Render of Template for ${orange(folder)} failed!`));
+                        this.emit('end');
+                    })
+                    .on('end', function () {
+                        console.log("🐶" + blue.underline(` => Render of Template for ${orange(folder)} succeeded!`));
+                    });
+    
+            // Register the task with Gulp
+            Object.defineProperty(task, 'name', { value: taskName }); // Set a unique name for debugging
+            return task;
+        });
+    
+        // Run all tasks in parallel
+        return gulp.parallel(...tasks);
 }

package/src/gulp/test.ts

@@ -1,82 +1,62 @@
 import gulp from 'gulp';
-import { blue, red } from '../index.js';
+import { blue, orange, red } from '../index.js';
 import gulpJest from 'gulp-jest';
+import { TaskOptions } from '../Gulpfile.js';
 const jest = gulpJest.default;
 
-export function test() {
-    return () => {
-        return gulp.src([
-            'typescript/backend/**/*.spec.ts',
-        ])
-        .pipe(jest({
-            verbose: true,
-            extensionsToTreatAsEsm: ['.ts'],
-            transform: {
-                '^.+\\.tsx?$': [
-                    'ts-jest',
-                    {
-                        tsconfig: './typescript/tsconfig.json',
-                        usESM: true,
-                    },
-                ],
-            },
-            preset: 'ts-jest',
-            setupFilesAfterEnv: [],
-            testEnvironment: 'node',
-            collectCoverage: true,
-            coverageDirectory: '../coverage',
-            coverageReporters: ['clover', 'json', 'lcov', 'text'],
-            rootDir: './typescript',
-            testMatch: ['**/*.spec.ts'],
-            passWithNoTests: true,
-            moduleNameMapper: {
-                'public/(.*)': '<rootDir>/public/$1'
-            }
-        }))
-            .on('error', function () {
-                console.log("💩" + red.underline.bold(' => Tests failed!'));
-                this.emit('end');
-            })
-            .on('end', function() { console.log("🐶" + blue.underline(' => Test succeeded!')); 
+export function test(options: TaskOptions) {
+    const folders = ['typescript'];
+    if (options.modulesSync){
+        for (const module of Object.keys(options.modulesSync)) {
+            folders.push(module);
         }
-    )}
-}
+    }
+    
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+        const taskName = `tests-${folder}`; // Create a unique name for each task
+        const task = () =>
+            gulp.src([
+                `${folder}/backend/**/*.spec.ts`,
+            ])
+            .pipe(jest({
+                verbose: true,
+                extensionsToTreatAsEsm: ['.ts'],
+                transform: {
+                    '^.+\\.tsx?$': [
+                        'ts-jest',
+                        {
+                            tsconfig: `./${folder}/tsconfig.json`,
+                            usESM: true,
+                        },
+                    ],
+                },
+                preset: 'ts-jest',
+                setupFilesAfterEnv: [],
+                testEnvironment: 'node',
+                collectCoverage: true,
+                coverageDirectory: './coverage',
+                coverageReporters: ['clover', 'json', 'lcov', 'text'],
+                rootDir: `./${folder}`,
+                testMatch: ['**/*.spec.ts'],
+                passWithNoTests: true,
+                moduleNameMapper: {
+                    'public/(.*)': '<rootDir>/public/$1'
+                }
+            }))
+                .on('error', function () {
+                    console.log("💩" + red.underline.bold(` => Tests for ${orange(folder)} failed!`));
+                    this.emit('end');
+                })
+                .on('end', function () {
+                    console.log("🐶" + blue.underline(` => Tests for ${orange(folder)} succeeded!`));
+                });
 
-export function testLib() {
-    return () => {
-        return gulp.src([
-            'lib/backend/**/*.spec.ts',
-        ])
-        .pipe(jest({
-            verbose: true,
-            extensionsToTreatAsEsm: ['.ts'],
-            transform: {
-                '^.+\\.tsx?$': [
-                    'ts-jest',
-                    {
-                        tsconfig: './lib/tsconfig.json',
-                        usESM: true,
-                    },
-                ],
-            },
-            preset: 'ts-jest',
-            setupFilesAfterEnv: [],
-            testEnvironment: 'node',
-            collectCoverage: true,
-            passWithNoTests: true,
-            coverageDirectory: './coverage',
-            coverageReporters: ['clover', 'json', 'lcov', 'text'],
-            rootDir: './lib',
-            testMatch: ['**/*.spec.ts'],
-            moduleNameMapper: {
-                'public/(.*)': '<rootDir>/public/$1'
-            }
-        }))
-            .on('error', function () {
-                console.log("💩" + red.underline.bold(' => Test (LIB) failed!'));
-                this.emit('end');
-            })
-            .on('end', function() { console.log("🐶" + blue.underline(' => Test (LIB) succeeded!')); 
-        }
-    )}
+        // Register the task with Gulp
+        Object.defineProperty(task, 'name', { value: taskName }); // Set a unique name for debugging
+        return task;
+    });
+
+    // Run all tasks in parallel
+    return gulp.parallel(...tasks);
 }