lucy-cli 0.7.15 → 0.8.1

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;

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/types.js

@@ -239,26 +239,17 @@ function processJson(obj) {
     }
 }
 function cleanTsConfig(json) {
-    // Process the paths object to remove duplicates
+    // const paths: Record<string, string[]> = {};
     if (json.compilerOptions?.paths) {
-        for (const key in json.compilerOptions.paths) {
-            if (Array.isArray(json.compilerOptions.paths[key])) {
-                const uniquePaths = [...new Set(json.compilerOptions.paths[key])];
-                json.compilerOptions.paths[key] = uniquePaths.length > 0 ? uniquePaths : undefined;
-            }
+        for (const [key, value] of Object.entries(json.compilerOptions.paths)) {
+            const uniquePaths = new Set(value);
+            json.compilerOptions.paths[key] = Array.from(uniquePaths);
+            // paths[key] = Array.from(uniquePaths);
         }
+        // json.compilerOptions.paths = paths;
     }
-    // Process the include array to remove duplicates
-    if (Array.isArray(json.include)) {
-        const uniqueIncludes = [...new Set(json.include)];
-        json.include = uniqueIncludes.length > 0 ? uniqueIncludes : undefined;
-    }
-    // Remove empty or undefined fields
-    if (json.compilerOptions?.paths) {
-        json.compilerOptions.paths = Object.fromEntries(Object.entries(json.compilerOptions.paths).filter(([_, value]) => value !== undefined));
-    }
-    if (json.include?.length === 0) {
-        delete json.include;
-    }
+    json.include = Array.from(new Set(json.include));
+    json.exclude = Array.from(new Set(json.exclude));
+    json.files = Array.from(new Set(json.files));
     return json;
 }

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/dist/models.d.ts

@@ -0,0 +1,37 @@
+export type TSConfig = {
+    compilerOptions?: {
+        target?: string;
+        module?: string;
+        lib?: string[];
+        outDir?: string;
+        rootDir?: string;
+        strict?: boolean;
+        esModuleInterop?: boolean;
+        allowJs?: boolean;
+        checkJs?: boolean;
+        declaration?: boolean;
+        declarationMap?: boolean;
+        sourceMap?: boolean;
+        removeComments?: boolean;
+        noImplicitAny?: boolean;
+        moduleResolution?: "node" | "classic";
+        resolveJsonModule?: boolean;
+        skipLibCheck?: boolean;
+        types?: string[];
+        typeRoots?: string[];
+        jsx?: "preserve" | "react" | "react-jsx" | "react-jsxdev" | "react-native";
+        incremental?: boolean;
+        noEmit?: boolean;
+        paths?: Record<string, string[]>;
+        [key: string]: any;
+    };
+    include?: string[];
+    exclude?: string[];
+    files?: string[];
+    extends?: string;
+    references?: {
+        path: string;
+    }[];
+    compileOnSave?: boolean;
+    [key: string]: any;
+};

package/dist/models.js

@@ -0,0 +1 @@
+export {};

package/files/typescript/templates/render.ts

@@ -0,0 +1,32 @@
+import * as fs from 'fs';
+
+
+export interface RenderToFsOPtions {
+    renderer: (arg0: any, arg1: any) => Promise<string>;
+    dataSource: string;
+    destination: string;
+}
+/**
+ * Render E-Mail to file system
+ * @param {RenderToFsOPtions} options Preview Options
+ * @returns {Promise<void>}
+ */
+export async function renderToFs(options: RenderToFsOPtions): Promise<void> {
+	if (process.env.NODE_ENV === 'production' || process.env.NODE_ENV === 'development') return;
+	console.log('rendered', process.env.NODE_ENV, options);
+	fs.readFile(`typescript/backend/templates/data/${options.dataSource}`, 'utf8', async (err, data) => {
+		if (err){
+			console.error('Template Rendere => ', err);
+			
+			return;
+		}
+		const fakeDate = JSON.parse(data) as any; 
+		console.log('fakeDate', fakeDate);
+		const html = await options.renderer(fakeDate, 'de');
+		fs.writeFile(`typescript/backend/templates/preview/${options.destination}.html`, html, err => {
+			if (err){
+				console.error(err);
+			}
+		});
+	});
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "lucy-cli",
-  "version": "0.7.15",
+  "version": "0.8.1",
   "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)));