lucy-cli 0.7.15 → 0.8.0

package/dist/gulp/test.js

@@ -1,11 +1,19 @@
 import gulp from 'gulp';
-import { blue, red } from '../index.js';
+import { blue, orange, red } from '../index.js';
 import gulpJest from 'gulp-jest';
 const jest = gulpJest.default;
-export function test() {
-    return () => {
-        return gulp.src([
-            'typescript/backend/**/*.spec.ts',
+export function test(options) {
+    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,
@@ -14,7 +22,7 @@ export function test() {
                 '^.+\\.tsx?$': [
                     'ts-jest',
                     {
-                        tsconfig: './typescript/tsconfig.json',
+                        tsconfig: `./${folder}/tsconfig.json`,
                         usESM: true,
                     },
                 ],
@@ -23,60 +31,26 @@ export function test() {
             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 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',
+            rootDir: `./${folder}`,
             testMatch: ['**/*.spec.ts'],
+            passWithNoTests: true,
             moduleNameMapper: {
                 'public/(.*)': '<rootDir>/public/$1'
             }
         }))
             .on('error', function () {
-            console.log("💩" + red.underline.bold(' => Test (LIB) failed!'));
+            console.log("💩" + red.underline.bold(` => Tests for ${orange(folder)} failed!`));
             this.emit('end');
         })
             .on('end', function () {
-            console.log("🐶" + blue.underline(' => Test (LIB) succeeded!'));
+            console.log("🐶" + blue.underline(` => Tests 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/dist/gulp/watchers.d.ts

@@ -1,15 +1,9 @@
 import { TaskOptions } from '../Gulpfile.js';
 export declare function watchSCSS(): import("fs").FSWatcher;
 export declare function watchBackend(): import("fs").FSWatcher;
-export declare function watchBackendLib(): import("fs").FSWatcher;
-export declare function watchJSW(): import("fs").FSWatcher;
-export declare function watchJSWLib(): import("fs").FSWatcher;
 export declare function watchPublic(): import("fs").FSWatcher;
-export declare function watchPublicLib(): import("fs").FSWatcher;
 export declare function watchPages(): import("fs").FSWatcher;
 export declare function watchFiles(): import("fs").FSWatcher;
-export declare function watchFilesLib(): import("fs").FSWatcher;
 export declare function watchTemplates(): import("fs").FSWatcher;
-export declare function watchTemplatesLib(): import("fs").FSWatcher;
 export declare function watchTypes(): import("fs").FSWatcher;
 export declare function watchAll(options: TaskOptions): import("undertaker").TaskFunction;

package/dist/gulp/watchers.js

@@ -1,85 +1,51 @@
 import gulp from 'gulp';
 import { green } from '../index.js';
-import { buildBackend, buildBackendJSW, buildBackendJSWLib, buildBackendLib } from './backend.js';
-import { buildPublic, buildPublicLib } from './public.js';
+import { buildBackend } from './backend.js';
+import { buildPublic } from './public.js';
 import { buildPages } from './pages.js';
-import { copyFiles, copyFilesLib } from './copy.js';
-import { previewTemplates, previewTemplatesLib } from './templates.js';
-import { checkTs, checkTsLib } from './checks.js';
-import { testLib, test } from './test.js';
+import { copyFiles } from './copy.js';
+import { previewTemplates } from './templates.js';
+import { checkTs } from './checks.js';
+import { test } from './test.js';
 let taskOptions;
 export function watchSCSS() {
     return gulp.watch([
-        'typescript/styles/**/*.scss',
-        'lib/styles/**/*.scss'
+        '*/styles/**/*.scss'
     ], gulp.parallel('scss'));
 }
 export function watchBackend() {
     return gulp.watch([
-        'typescript/backend/**/*.ts',
-        'typescript/backend/**/*.tsx',
-        '!typescript/backend/**/*.spec.ts',
-        '!typescript/backend/**/*.jsw.ts',
-    ], gulp.parallel(test(), checkTs(), buildBackend(taskOptions)));
-}
-export function watchBackendLib() {
-    return gulp.watch([
-        'lib/backend/**/*.ts',
-        'lib/backend/**/*.tsx',
-        '!lib/backend/**/*.spec.ts',
-        '!lib/backend/**/*.jsw.ts',
-    ], gulp.parallel(testLib(), checkTsLib(), buildBackendLib(taskOptions)));
-}
-export function watchJSW() {
-    return gulp.watch(['typescript/backend/**/*.jsw.ts'], gulp.parallel(test(), checkTs(), buildBackendJSW(taskOptions)));
-}
-export function watchJSWLib() {
-    return gulp.watch(['lib/backend/**/*.jsw.ts'], gulp.parallel(testLib(), checkTsLib(), buildBackendJSWLib(taskOptions)));
+        '*/backend/**/*.ts',
+        '*/backend/**/*.tsx',
+        '!*/backend/**/*.spec.ts',
+        '!*/backend/**/*.jsw.ts',
+        '!src/**/**',
+    ], gulp.parallel(test(taskOptions), checkTs(taskOptions), buildBackend(taskOptions)));
 }
 export function watchPublic() {
     return gulp.watch([
-        'typescript/public/**/*.ts',
-        'typescript/public/**/*.tsx',
-    ], gulp.parallel(test(), checkTs(), buildPublic(taskOptions)));
-}
-export function watchPublicLib() {
-    return gulp.watch([
-        'lib/public/**/*.ts',
-        'lib/public/**/*.tsx',
-    ], gulp.parallel(testLib(), checkTsLib(), buildPublicLib(taskOptions)));
+        '*/public/**/*.ts',
+        '*/public/**/*.tsx',
+    ], gulp.parallel(test(taskOptions), checkTs(taskOptions), buildPublic(taskOptions)));
 }
 export function watchPages() {
-    return gulp.watch('typescript/pages/**/*.ts', gulp.parallel(checkTs(), buildPages(taskOptions)));
+    return gulp.watch('typescript/pages/**/*.ts', gulp.parallel(checkTs(taskOptions), buildPages(taskOptions)));
 }
 export function watchFiles() {
     return gulp.watch([
-        'typescript/backend/**/*',
-        'typescript/public/**/*',
-        'typescript/pages/**/*',
-        '!typescript/**/*.ts',
+        '*/backend/**/*',
+        '*/public/**/*',
+        '*/pages/**/*',
+        '!*/**/*.ts',
+        '!*/**/*.tsx',
     ], gulp.parallel(copyFiles(taskOptions)));
 }
-export function watchFilesLib() {
-    return gulp.watch([
-        'lib/backend/**/*',
-        'lib/public/**/*',
-        'lib/pages/**/*',
-        '!lib/**/*.ts',
-    ], gulp.parallel(copyFilesLib(taskOptions)));
-}
 export function watchTemplates() {
     return gulp.watch([
-        'typescript/backend/templates/**/*.tsx',
-        'typescript/backend/templates/data/*.json',
-        '!typescript/backend/templates/render.ts',
-    ], gulp.parallel(previewTemplates(), test()));
-}
-export function watchTemplatesLib() {
-    return gulp.watch([
-        'lib/backend/templates/**/*.tsx',
-        'lib/backend/templates/data/*.json',
-        '!lib/backend/templates/render.ts',
-    ], gulp.parallel(previewTemplatesLib(), testLib()));
+        '*/backend/templates/**/*.tsx',
+        '*/backend/templates/data/*.json',
+        '!*/backend/templates/render.ts',
+    ], gulp.parallel(previewTemplates(taskOptions), test(taskOptions), checkTs(taskOptions)));
 }
 export function watchTypes() {
     return gulp.watch([
@@ -90,5 +56,5 @@ export function watchTypes() {
 export function watchAll(options) {
     taskOptions = options;
     console.log("🐕" + green.underline.bold(' => Adding watchers...'));
-    return gulp.parallel(watchSCSS, watchBackend, watchBackendLib, watchJSW, watchJSWLib, watchPublic, watchPublicLib, watchPages, watchFilesLib, watchFiles, watchTemplates, watchTemplatesLib, watchTypes);
+    return gulp.parallel(watchSCSS, watchBackend, watchPublic, watchPages, watchFiles, watchTemplates, watchTypes);
 }

package/dist/helpers.d.ts

@@ -2,3 +2,7 @@ import { ModuleSettings, ProjectSettings } from '.';
 export declare function installPackages(wixPackages: Record<string, string>, devPackages: Record<string, string>, cwd: string, locked: boolean): Promise<void>;
 export declare function gitInit(cwd: string, modules: Record<string, string>): Promise<void>;
 export declare function runGulp(moduleSettings: ModuleSettings, projectSettings: ProjectSettings, task: string): Promise<void>;
+/**
+ * Clean up and run a command before exiting the process.
+ */
+export declare function handleExit(): void;

package/dist/helpers.js

@@ -4,6 +4,7 @@ import { spawnSync } from 'child_process';
 // https://www.sergevandenoever.nl/run-gulp4-tasks-programatically-from-node/
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { exec } from 'child_process';
 import { blue, green, orange, red } from './index.js';
 export async function installPackages(wixPackages, devPackages, cwd, locked) {
     if (locked)
@@ -67,3 +68,21 @@ export async function runGulp(moduleSettings, projectSettings, task) {
     // Check if 'dev' task exists
     gulpfile.runTask(task, moduleSettings, projectSettings);
 }
+/**
+ * Clean up and run a command before exiting the process.
+ */
+export function handleExit() {
+    const cwd = process.cwd();
+    const command = `watchman watch-del '${cwd}'`;
+    console.log("🐕" + blue.underline(' => Cleaning up...'));
+    exec(command, (error, stdout, stderr) => {
+        if (error) {
+            console.error(`💩 Failed to run cleanup: ${error.message}`);
+            return;
+        }
+        if (stderr) {
+            console.error(`⚠️  Watchman stderr: ${stderr}`);
+        }
+        console.log(`✅ Watchman cleanup success: ${stdout}`);
+    });
+}

package/dist/index.js

@@ -9,7 +9,7 @@ import { join } from 'path';
 import fs from 'fs/promises';
 import { init } from './init.js';
 import { sync } from './sync.js';
-import { runGulp, installPackages } from './helpers.js';
+import { runGulp, installPackages, handleExit } from './helpers.js';
 import { prepare } from './prepare.js';
 export const orange = chalk.hex('#FFA500');
 export const blue = chalk.blueBright;
@@ -21,6 +21,11 @@ export const magenta = chalk.magentaBright;
 const __filename = fileURLToPath(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/naming-convention
 const __dirname = dirname(__filename);
+process.on('SIGINT', () => {
+    console.log("🐕 Received Ctrl+C, cleaning up...");
+    handleExit();
+    process.exit(); // Exit the process explicitly
+});
 /**
  * Main function
  * @returns {Promise<void>}
@@ -114,6 +119,7 @@ async function main() {
     }
     if (moduleSettings.args.includes('-l'))
         moduleSettings.lockVersion = true;
+    console.log("🐕" + magenta.underline(' => Lucy CLI => RUNNING: ' + orange('Press Ctrl+C to stop.')));
     // INFO: Run commands
     if (moduleSettings.args.includes('init')) {
         if (projectSettings.lucySettings?.initialized && !moduleSettings.force) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "lucy-cli",
-  "version": "0.7.15",
+  "version": "0.8.0",
   "description": "Lucy Framework for WIX Studio Editor",
   "main": ".dist/index.js",
   "scripts": {

package/settings/master-settings.json

@@ -6,7 +6,6 @@
     "jsx": "react-jsx",
     "noEmit": false,
     "noUncheckedIndexedAccess": true,
-    "lib": ["DOM", "ESNext"],
     "paths": {
       "backend/*.web.js": [],
       "backend/*.web": [],

package/settings/page-settings.json

@@ -7,7 +7,6 @@
     "jsx": "react-jsx",
     "noEmit": false,
     "noUncheckedIndexedAccess": true,
-    "lib": ["DOM", "ESNext"],
     "paths": {
       "backend/*.web.js": [],
       "backend/*.web": [],

package/settings/public-settings.json

@@ -6,7 +6,6 @@
     "strict": true,
     "jsx": "react-jsx",
     "strictNullChecks": true,
-    "lib": ["DOM", "ESNext"],
     "paths": {
       "backend/*.web.js": [],
       "backend/*.web": [],

package/src/Gulpfile.ts

@@ -9,19 +9,20 @@ import masterSettings from '../settings/master-settings.json' assert { type: 'js
 import pageSettings from '../settings/page-settings.json' assert { type: 'json' };
 import publicSettings from '../settings/public-settings.json' assert { type: 'json' };
 
-import { buildPublic, buildPublicLib } from './gulp/public.js';
-import { buildBackend, buildBackendHTTP, buildBackendJSW, buildBackendJSWLib, buildBackendLib } from './gulp/backend.js';
-import { checkPages, checkTs, checkTsLib } from './gulp/checks.js';
+import { buildPublic } from './gulp/public.js';
+import { buildBackend, buildBackendJSW } from './gulp/backend.js';
+import { checkPages, checkTs } from './gulp/checks.js';
 import { compileScss } from './gulp/styles.js';
 import { buildPages } from './gulp/pages.js';
-import { previewTemplates, previewTemplatesLib } from './gulp/templates.js';
-import { copyFiles, copyFilesLib } from './gulp/copy.js';
+import { previewTemplates } from './gulp/templates.js';
+import { copyFiles } from './gulp/copy.js';
 import { cleanSrc, cleanWix } from './gulp/clean.js';
 import { addTypes, updateWixTypes } from './gulp/types.js';
 import { setProdConfig } from './gulp/pipeline.js';
 import { watchAll } from './gulp/watchers.js';
 import { ModuleSettings, ProjectSettings, green, magenta, orange, red } from './index.js';
-import { testLib, test } from './gulp/test.js';
+import { test } from './gulp/test.js';
+import { getModulesSync } from './gulp/helpers.js';
 
 const sass = gulpSass(dartSass);
 
@@ -37,6 +38,7 @@ export type TaskOptions = {
 	masterSettings: typeof masterSettings,
 	pageSettings: typeof pageSettings,
 	publicSettings: typeof publicSettings,
+	modulesSync: Record<string, string> | undefined;
 	cwd: string;
 }
 
@@ -64,11 +66,11 @@ const taskOptions: TaskOptions = {
 	masterSettings, 
 	replaceOptions,
 	cwd: process.cwd(),
+	modulesSync: getModulesSync(),
 }
 
 gulp.task('check-ts', gulp.parallel( 
-	checkTs(),
-	checkTsLib(),
+	checkTs(taskOptions),
 ));
 
 gulp.task('scss', gulp.parallel( 
@@ -77,30 +79,24 @@ gulp.task('scss', gulp.parallel(
 
 gulp.task('build-backend', gulp.parallel( 
 	buildBackend(taskOptions),
-	buildBackendLib(taskOptions),
 	buildBackendJSW(taskOptions),
-	buildBackendJSWLib(taskOptions),
 	// buildBackendHTTP(taskOptions),
 ));
 
 gulp.task('build-public', gulp.parallel( 
 	buildPublic(taskOptions),
-	buildPublicLib(taskOptions),
 ));
 
 gulp.task('preview-templates', gulp.parallel(
-	previewTemplates(),
-	previewTemplatesLib()
+	previewTemplates(taskOptions),
 ));
 
 gulp.task('copy-files', gulp.parallel(
 	copyFiles(taskOptions),
-	copyFilesLib(taskOptions)
 ));
 
 gulp.task('test', gulp.parallel(
-	test(),
-	testLib(),
+	test(taskOptions),
 ));
 
 gulp.task('sync-types', shell.task([
@@ -196,7 +192,7 @@ async function gulpTaskRunner(task: string) {
 }
 
 export async function runTask(task: string, moduleSettings: ModuleSettings, projectSettings: ProjectSettings) {
-	taskOptions.cwd = moduleSettings.targetFolder;
+	taskOptions.cwd =  moduleSettings.targetFolder;
 	taskOptions.moduleSettings = moduleSettings;
 	taskOptions.projectSettings = projectSettings;
 	console.log("🐕" + magenta.underline(' => Starting Task => ' +  orange(task)));

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);
 }