lucy-cli 0.7.14 → 0.8.0

package/dist/Gulpfile.d.ts

@@ -16,6 +16,7 @@ export type TaskOptions = {
     masterSettings: typeof masterSettings;
     pageSettings: typeof pageSettings;
     publicSettings: typeof publicSettings;
+    modulesSync: Record<string, string> | undefined;
     cwd: string;
 };
 export interface File {

package/dist/Gulpfile.js

@@ -7,19 +7,20 @@ import backendSettings from '../settings/backend-settings.json' assert { type: '
 import masterSettings from '../settings/master-settings.json' assert { type: 'json' };
 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, 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 { 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);
 const outputDir = './src';
 const userHomeDir = os.homedir();
@@ -39,14 +40,15 @@ const taskOptions = {
     masterSettings,
     replaceOptions,
     cwd: process.cwd(),
+    modulesSync: getModulesSync(),
 };
-gulp.task('check-ts', gulp.parallel(checkTs(), checkTsLib()));
+gulp.task('check-ts', gulp.parallel(checkTs(taskOptions)));
 gulp.task('scss', gulp.parallel(compileScss(taskOptions)));
-gulp.task('build-backend', gulp.parallel(buildBackend(taskOptions), buildBackendLib(taskOptions), buildBackendJSW(taskOptions), buildBackendJSWLib(taskOptions)));
-gulp.task('build-public', gulp.parallel(buildPublic(taskOptions), buildPublicLib(taskOptions)));
-gulp.task('preview-templates', gulp.parallel(previewTemplates(), previewTemplatesLib()));
-gulp.task('copy-files', gulp.parallel(copyFiles(taskOptions), copyFilesLib(taskOptions)));
-gulp.task('test', gulp.parallel(test(), testLib()));
+gulp.task('build-backend', gulp.parallel(buildBackend(taskOptions), buildBackendJSW(taskOptions)));
+gulp.task('build-public', gulp.parallel(buildPublic(taskOptions)));
+gulp.task('preview-templates', gulp.parallel(previewTemplates(taskOptions)));
+gulp.task('copy-files', gulp.parallel(copyFiles(taskOptions)));
+gulp.task('test', gulp.parallel(test(taskOptions)));
 gulp.task('sync-types', shell.task([
     'yarn postinstall',
 ]));

package/dist/gulp/backend.d.ts

@@ -1,6 +1,3 @@
 import { TaskOptions } from '../Gulpfile';
-export declare function buildBackend(options: TaskOptions): () => NodeJS.ReadWriteStream;
-export declare function buildBackendLib(options: TaskOptions): () => NodeJS.ReadWriteStream;
-export declare function buildBackendJSW(options: TaskOptions): () => NodeJS.ReadWriteStream;
-export declare function buildBackendJSWLib(options: TaskOptions): () => NodeJS.ReadWriteStream;
-export declare function buildBackendHTTP(options: TaskOptions): () => NodeJS.ReadWriteStream;
+export declare function buildBackend(options: TaskOptions): import("undertaker").TaskFunction;
+export declare function buildBackendJSW(options: TaskOptions): import("undertaker").TaskFunction;

package/dist/gulp/backend.js

@@ -2,117 +2,78 @@ import gulp from 'gulp';
 import { createGulpEsbuild } from 'gulp-esbuild';
 import rename from 'gulp-rename';
 import * as path from 'path';
-import { blue, red } from '../index.js';
-import ts from 'gulp-typescript';
-import tsConf from '../../files/typescript/tsconfig.json' assert { type: 'json' };
-const tsOptions = tsConf.compilerOptions;
+import { blue, orange, red } from '../index.js';
 export function buildBackend(options) {
+    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/backend/**/*.ts',
-            'typescript/backend/**/*.tsx',
-            '!typescript/backend/**/*.jsw.ts',
-            '!typescript/backend/**/*.spec.ts',
-            '!typescript/backend/http-functions.ts',
+    // 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 TS files failed!'));
+            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 TS files succeeded!'));
+            console.log("🐶" + blue.underline(` => Build of Backend files for ${orange(folder)} succeeded!`));
         });
-    };
-}
-export function buildBackendLib(options) {
-    const { outputDir, enableIncrementalBuild } = options;
-    const gulpEsbuild = createGulpEsbuild({
-        incremental: enableIncrementalBuild,
+        // Register the task with Gulp
+        Object.defineProperty(task, 'name', { value: taskName }); // Set a unique name for debugging
+        return task;
     });
-    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!'));
-        });
-    };
+    // Run all tasks in parallel
+    return gulp.parallel(...tasks);
 }
 export function buildBackendJSW(options) {
+    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/backend/**/*.jsw.ts'])
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+        const taskName = `build-${folder}`; // Create a unique name for each task
+        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 failed!'));
+            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 succeeded!')); });
-    };
-}
-export function buildBackendJSWLib(options) {
-    const { outputDir, enableIncrementalBuild } = options;
-    const gulpEsbuild = createGulpEsbuild({
-        incremental: enableIncrementalBuild,
+            .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;
     });
-    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!')); });
-    };
-}
-export function buildBackendHTTP(options) {
-    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!')); });
-    };
+    // Run all tasks in parallel
+    return gulp.parallel(...tasks);
 }

package/dist/gulp/checks.d.ts

@@ -1,3 +1,3 @@
+import { TaskOptions } from '../Gulpfile.js';
 export declare function checkPages(fail: boolean, force: boolean): Promise<void>;
-export declare function checkTs(): () => import("gulp-typescript/release/project.js").ICompileStream;
-export declare function checkTsLib(): () => import("gulp-typescript/release/project.js").ICompileStream;
+export declare function checkTs(options: TaskOptions): import("undertaker").TaskFunction;

package/dist/gulp/checks.js

@@ -3,7 +3,7 @@ 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';
 /**
  *  Extracts a match from a file
  * @param {string} filePath File path
@@ -115,31 +115,30 @@ export async function checkPages(fail, force) {
         }
     });
 }
-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 checkTsLib() {
-    const tsProject = ts.createProject('./lib/tsconfig.json', { noEmit: true });
-    return () => {
-        return gulp.src(['lib/typescript/**/*.ts', '!lib/typescript/types/**/*.ts'], { cwd: 'typescript' })
+export function checkTs(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 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(' => Typescript (LIB) error!'));
+            console.log("💩" + red.underline.bold(` => Typescriptcheck for ${orange(folder)} failed!`));
             this.emit('end');
         })
             .on('end', function () {
-            console.log("🐶" + blue.underline(' => Typescript check (LIB) succeeded!'));
+            console.log("🐶" + blue.underline(` => Typescriptcheck 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/copy.d.ts

@@ -1,3 +1,2 @@
 import { TaskOptions } from '../Gulpfile';
-export declare function copyFiles(options: TaskOptions): () => NodeJS.ReadWriteStream;
-export declare function copyFilesLib(options: TaskOptions): () => NodeJS.ReadWriteStream;
+export declare function copyFiles(options: TaskOptions): import("undertaker").TaskFunction;

package/dist/gulp/copy.js

@@ -1,42 +1,37 @@
 import gulp from 'gulp';
-import { blue, red } from '../index.js';
+import { blue, orange, red } from '../index.js';
 export function copyFiles(options) {
-    const { outputDir } = options;
-    return () => {
-        return gulp.src([
-            'typescript/**/*',
-            '!typescript/*tsconfig.json',
-            '!typescript/**/*.ts',
-            '!typescript/**/*.tsx',
-            '!typescript/types/**/**',
-            '!typescript/__mocks__/**/**',
-            '!typescript/styles/**',
+    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 { outputDir } = options;
+        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 failed!'));
+            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 succeeded!')); });
-    };
-}
-export function copyFilesLib(options) {
-    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!')); });
-    };
+            .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/dist/gulp/helpers.d.ts

@@ -0,0 +1 @@
+export declare function getModulesSync(): Record<string, string> | undefined;

package/dist/gulp/helpers.js

@@ -0,0 +1,7 @@
+import * as path from 'path';
+import * as fs from 'fs';
+export function getModulesSync() {
+    const absolutePath = path.resolve('./lucy.json');
+    const fileContent = fs.readFileSync(absolutePath, 'utf8');
+    return JSON.parse(fileContent).modules;
+}

package/dist/gulp/public.d.ts

@@ -1,3 +1,2 @@
 import { TaskOptions } from '../Gulpfile';
-export declare function buildPublic(options: TaskOptions): () => NodeJS.ReadWriteStream;
-export declare function buildPublicLib(options: TaskOptions): () => NodeJS.ReadWriteStream;
+export declare function buildPublic(options: TaskOptions): import("undertaker").TaskFunction;

package/dist/gulp/public.js

@@ -1,16 +1,24 @@
 import gulp from 'gulp';
 import { createGulpEsbuild } from 'gulp-esbuild';
 import * as path from 'path';
-import { blue, red } from '../index.js';
+import { blue, orange, red } from '../index.js';
 export function buildPublic(options) {
+    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',
+    // Create tasks for each folder
+    const tasks = folders.map((folder) => {
+        const taskName = `build_Public-${folder}`; // Create a unique name for each task
+        const task = () => gulp.src([
+            `${folder}/public/**/*.ts`,
+            `${folder}/public/**/*.tsx`,
         ])
             .pipe(gulpEsbuild({
             bundle: false,
@@ -20,37 +28,16 @@ export function buildPublic(options) {
         }))
             .pipe(gulp.dest(path.join(outputDir, 'public')))
             .on('error', function () {
-            console.log("💩" + red.underline.bold(' => Build of Public TS files failed!'));
+            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 TS files succeeded!'));
+            console.log("🐶" + blue.underline(` => Build of Public files for ${orange(folder)} succeeded!`));
         });
-    };
-}
-export function buildPublicLib(options) {
-    const { outputDir, enableIncrementalBuild } = options;
-    const gulpEsbuild = createGulpEsbuild({
-        incremental: enableIncrementalBuild,
+        // 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/dist/gulp/styles.d.ts

@@ -1,2 +1,2 @@
 import { TaskOptions } from '../Gulpfile';
-export declare function compileScss(options: TaskOptions): () => NodeJS.ReadWriteStream;
+export declare function compileScss(options: TaskOptions): import("undertaker").TaskFunction;

package/dist/gulp/styles.js

@@ -1,17 +1,30 @@
 import gulp from 'gulp';
-import { blue, red } from '../index.js';
+import { blue, orange, red } from '../index.js';
 export function compileScss(options) {
+    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'])
+    // 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 failed!'));
+            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 succeeded!'));
+            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/dist/gulp/templates.d.ts

@@ -1,2 +1,2 @@
-export declare function previewTemplates(): () => any;
-export declare function previewTemplatesLib(): () => any;
+import { TaskOptions } from '../Gulpfile';
+export declare function previewTemplates(options: TaskOptions): import("undertaker").TaskFunction;

package/dist/gulp/templates.js

@@ -1,39 +1,36 @@
 import gulp from 'gulp';
 import exec from 'gulp-exec';
-import { blue, red } from '../index.js';
-export function previewTemplates() {
-    const options = {
+import { blue, orange, red } from '../index.js';
+export function previewTemplates(options) {
+    const folders = ['typescript'];
+    if (options.modulesSync) {
+        for (const module of Object.keys(options.modulesSync)) {
+            folders.push(module);
+        }
+    }
+    const taskOpt = {
         continueOnError: true,
     };
-    return () => {
-        return gulp.src([
-            'typescript/backend/templates/**/*.tsx',
-            'typescript/backend/templates/data/*.json',
-            '!typescript/backend/templates/render.ts',
+    // 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) => `npx ts-node-esm -T ${file.path}`, options))
+            .pipe(exec((file) => `npx ts-node-esm -T ${file.path}`, taskOpt))
             .on('error', function () {
-            console.log("💩" + red.underline.bold(' => Render of Template failed!'));
+            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 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) => `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!')); });
-    };
+            .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/dist/gulp/test.d.ts

@@ -1,2 +1,2 @@
-export declare function test(): () => any;
-export declare function testLib(): () => any;
+import { TaskOptions } from '../Gulpfile.js';
+export declare function test(options: TaskOptions): import("undertaker").TaskFunction;