lucy-cli 0.7.15 → 0.8.1

package/src/gulp/backend.ts

@@ -3,130 +3,97 @@ import { createGulpEsbuild } from 'gulp-esbuild';
 import rename from 'gulp-rename';
 import * as path from 'path';
 import { TaskOptions } from '../Gulpfile';
-import { blue, red } from '../index.js';
-import ts from 'gulp-typescript';
-import merge from 'merge2';
-import esbuild from 'gulp-esbuild';
-import concat from 'gulp-concat';
-import tsConf from '../../files/typescript/tsconfig.json' assert { type: 'json' };
-
-
-type TsSettings = ts.Settings;
-const tsOptions:TsSettings = tsConf.compilerOptions;
+import { blue, orange, red } from '../index.js';
 
 export function buildBackend(options: TaskOptions) {
-    const { outputDir, enableIncrementalBuild } = options;
-    const gulpEsbuild = createGulpEsbuild({
-        incremental: enableIncrementalBuild,
-    });
-    
-    return () => {
-        return gulp.src([
-            'typescript/backend/**/*.ts', 
-            'typescript/backend/**/*.tsx', 
-            '!typescript/backend/**/*.jsw.ts', 
-            '!typescript/backend/**/*.spec.ts',
-            '!typescript/backend/http-functions.ts',
-        ])
-            .pipe(gulpEsbuild({
-                bundle: false,
-            }))
-            .pipe(gulp.dest(path.join(outputDir, 'backend')))
-            .on('error', function () {
-                console.log("💩" + red.underline.bold(' => Build of Backend TS files failed!'));
-                this.emit('end');
-            })
-            .on('end', function() { console.log("🐶" + blue.underline(' => Build of Backend TS files succeeded!')); 
+    const folders = ['typescript'];
+    if (options.modulesSync){
+        for (const module of Object.keys(options.modulesSync)) {
+            folders.push(module);
         }
-    )}
-}
+    }
 
-export function buildBackendLib(options: TaskOptions) {
     const { outputDir, enableIncrementalBuild } = options;
     const gulpEsbuild = createGulpEsbuild({
         incremental: enableIncrementalBuild,
     });
-    
-    return () => {
-        return gulp.src([
-            'lib/backend/**/*.ts', 
-            'lib/backend/**/*.tsx', 
-            '!lib/backend/**/*.jsw.ts', 
-            '!lib/backend/**/*.spec.ts',
-            '!lib/backend/http-functions.ts',
-        ])
-            .pipe(gulpEsbuild({
-                bundle: false,
-            }))
-            .pipe(gulp.dest(path.join(outputDir, 'backend')))
-            .on('error', function () {
-                console.log("💩" + red.underline.bold(' => Build of Backend TS (LIB) files failed!'));
-                this.emit('end');
-            })
-            .on('end', function() { console.log("🐶" + blue.underline(' => Build of Backend TS (LIB) files succeeded!')); 
-        }
-    )}
-}
 
-export function buildBackendJSW(options: TaskOptions) {
-    const { outputDir, enableIncrementalBuild } = options;
-    const gulpEsbuild = createGulpEsbuild({
-        incremental: enableIncrementalBuild,
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+        const taskName = `build_Backend-${folder}`; // Create a unique name for each task
+
+        const task = () =>
+            gulp.src([
+                `${folder}/backend/**/*.ts`,
+                `${folder}/backend/**/*.tsx`,
+                `!${folder}/backend/**/*.jsw.ts`,
+                `!${folder}/backend/**/*.spec.ts`,
+            ])
+                .pipe(
+                    gulpEsbuild({
+                        bundle: false,
+                    })
+                )
+                .pipe(gulp.dest(path.join(outputDir, 'backend')))
+                .on('error', function () {
+                    console.log("💩" + red.underline.bold(` => Build of Backend files for ${orange(folder)} failed!`));
+                    this.emit('end');
+                })
+                .on('end', function () {
+                    console.log("🐶" + blue.underline(` => Build of Backend 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(['typescript/backend/**/*.jsw.ts'])
-		.pipe(gulpEsbuild({
-			bundle: false,
-		}))
-		.pipe(rename({ extname: '' }))
-		.pipe(gulp.dest(path.join(outputDir, 'backend')))
-		.on('error', function () {
-			console.log("💩" + red.underline.bold(' => Build of JSW files failed!'));
-			this.emit('end');
-		})
-        .on('end', function() { console.log("🐶" + blue.underline(' => Build of (JSW) files succeeded!'))})
-    }
+    // Run all tasks in parallel
+    return gulp.parallel(...tasks);
 }
 
-export function buildBackendJSWLib(options: TaskOptions) {
+
+export function buildBackendJSW(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(['lib/backend/**/*.jsw.ts'])
-		.pipe(gulpEsbuild({
-			bundle: false,
-		}))
-		.pipe(rename({ extname: '' }))
-		.pipe(gulp.dest(path.join(outputDir, 'backend')))
-		.on('error', function () {
-			console.log("💩" + red.underline.bold(' => Build of JSW (LIB) files failed!'));
-			this.emit('end');
-		})
-        .on('end', function() { console.log("🐶" + blue.underline(' => Build of JSW (LIB) files succeeded!'))})
-    }
-}
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+        const taskName = `build-${folder}`; // Create a unique name for each task
 
-export function buildBackendHTTP(options: TaskOptions) {
-    const { outputDir, enableIncrementalBuild } = options;
-    delete tsOptions.outFile;
-    delete tsOptions.outDir;
-    delete tsOptions.rootDir;
-    // tsOptions.resolveJsonModule = false;
-    tsOptions.module = 'amd';
-    tsOptions.outFile = 'http-functions.js';
-console.log({tsOptions})
-    return () => {
-        return gulp.src(['lib/backend/http-functions.ts', 'typescript/backend/http-functions.ts'])
-        .pipe(ts(tsOptions))
-        .pipe(gulp.dest(path.join(outputDir, 'backend')))
-        .on('error', function () {
-			console.log("💩" + red.underline.bold(' => Build of HTTP (LIB) files failed!'));
-			this.emit('end');
-		})
-        .on('end', function() { console.log("🐶" + blue.underline(' => Build of HTTP (LIB) files succeeded!'))})
-    };
+        const task = () =>
+            gulp.src([
+                `${folder}/backend/**/*.jsw.ts`,
+            ])
+                .pipe(
+                    gulpEsbuild({
+                        bundle: false,
+                    })
+                )
+                .pipe(rename({ extname: '' }))
+                .pipe(gulp.dest(path.join(outputDir, 'backend')))
+                .on('error', function () {
+                    console.log("💩" + red.underline.bold(` => Build of JSW files for ${orange(folder)} failed!`));
+                    this.emit('end');
+                })
+                .on('end', function () {
+                    console.log("🐶" + blue.underline(` => Build of JSW 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/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,46 @@
 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);
 }