lucy-cli 0.7.15 → 0.8.1

package/src/gulp/test.ts

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

package/src/gulp/types.ts

@@ -9,6 +9,7 @@ import merge from 'merge-stream';
 import * as insert from 'gulp-insert';
 import { blue, red, yellow } from '../index.js';
 import tap from 'gulp-tap';
+import { TSConfig } from '../models';
 
 export function updateWixTypes(options: TaskOptions) {
     return () => {
@@ -111,29 +112,29 @@ export function updateWixTypes(options: TaskOptions) {
 			count ++;
 			if (file.dirname.endsWith('public')) {
 				return stream.pipe(jeditor(publicSettings))
-						.pipe(jeditor((json: any) => cleanTsConfig(json)))
-						.pipe(jeditor((json: any) => processJson(json)))
-						.pipe(replace('"../backend.d.ts",', '', replaceOptions))
-						.pipe(replace('"../../../src/backend/\\*\\*/\\*.web.js",', '', replaceOptions));
+					.pipe(jeditor((json: any) => cleanTsConfig(json)))
+					.pipe(jeditor((json: any) => processJson(json)))
+					.pipe(replace('"../backend.d.ts",', '', replaceOptions))
+					.pipe(replace('"../../../src/backend/\\*\\*/\\*.web.js",', '', replaceOptions));
 			}
 			if (file.dirname.endsWith('backend')) {
 				return stream.pipe(jeditor(backendSettings))
-						.pipe(jeditor((json: any) => cleanTsConfig(json)))
-						.pipe(jeditor((json: any) => processJson(json)))
+					.pipe(jeditor((json: any) => cleanTsConfig(json)))
+					.pipe(jeditor((json: any) => processJson(json)))
 			};
 			if (file.dirname.endsWith('masterPage')) {
 				return stream.pipe(jeditor(masterSettings))
-						.pipe(jeditor((json: any) => cleanTsConfig(json)))
-						.pipe(jeditor((json: any) => processJson(json)))
-						.pipe(replace('"../backend.d.ts",', '', replaceOptions))
-						.pipe(replace('"../../../src/backend/\\*\\*/\\*.web.js",', '', replaceOptions));
-			};
-			
-			return stream.pipe(jeditor(pageSettings))
 					.pipe(jeditor((json: any) => cleanTsConfig(json)))
 					.pipe(jeditor((json: any) => processJson(json)))
 					.pipe(replace('"../backend.d.ts",', '', replaceOptions))
 					.pipe(replace('"../../../src/backend/\\*\\*/\\*.web.js",', '', replaceOptions));
+			};
+			
+			return stream.pipe(jeditor(pageSettings))
+				.pipe(jeditor((json: any) => cleanTsConfig(json)))
+				.pipe(jeditor((json: any) => processJson(json)))
+				.pipe(replace('"../backend.d.ts",', '', replaceOptions))
+				.pipe(replace('"../../../src/backend/\\*\\*/\\*.web.js",', '', replaceOptions));
 		}))
 		.pipe(replace('masterPage.masterPage.js', 'masterPage.ts', replaceOptions))
 		.pipe(replace('/src/', '/typescript/', replaceOptions))
@@ -259,33 +260,19 @@ function processJson(obj: any): any {
     }
 }
 
-function cleanTsConfig(json: any): any {
-    // Process the paths object to remove duplicates
-    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;
-            }
-        }
-    }
-
-    // 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;
-    }
+function cleanTsConfig(json: TSConfig): TSConfig {
+	// const paths: Record<string, string[]> = {};
+	if (json.compilerOptions?.paths) {
+		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;
+	}
+	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;
+	return json;
 }

package/src/gulp/watchers.ts

@@ -1,100 +1,55 @@
 import gulp from 'gulp';
 import { TaskOptions } from '../Gulpfile.js';
 import { green } from '../index.js';
-import { buildBackend, buildBackendJSW, buildBackendJSWLib, buildBackendLib } from './backend.js';
-import { buildPublic, buildPublicLib } from './public.js';
+import { buildBackend, buildBackendJSW } 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 { checkPages, checkTs, checkTsLib } from './checks.js';
-import { testLib, test } from './test.js';
+import { copyFiles } from './copy.js';
+import { previewTemplates } from './templates.js';
+import { checkPages, checkTs } from './checks.js';
+import { test } from './test.js';
 
 let taskOptions: 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', 
+		'*/backend/**/*.ts', 
+		'*/backend/**/*.tsx', 
+		'!*/backend/**/*.spec.ts',
+        '!*/backend/**/*.jsw.ts', 
+        '!src/**/**',
 	], gulp.parallel(
-        test(),
-        checkTs(),
+        test(taskOptions),
+        checkTs(taskOptions),
         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)
-        )
-    );
-}
-
 export function watchPublic() {
     return gulp.watch([
-		'typescript/public/**/*.ts', 
-		'typescript/public/**/*.tsx',
+		'*/public/**/*.ts', 
+		'*/public/**/*.tsx',
 	], gulp.parallel(
-        test(),
-        checkTs(),
+        test(taskOptions),
+        checkTs(taskOptions),
         buildPublic(taskOptions),
         )
     );
 }
 
-export function watchPublicLib() {
-    return gulp.watch([
-		'lib/public/**/*.ts', 
-		'lib/public/**/*.tsx',
-	], gulp.parallel(
-        testLib(),
-        checkTsLib(),
-        buildPublicLib(taskOptions),
-        )
-    );
-}
-
 export function watchPages() {
     return 	gulp.watch('typescript/pages/**/*.ts', 
     gulp.parallel(
-        checkTs(),
+        checkTs(taskOptions),
         buildPages(taskOptions),
         )
     );
@@ -102,42 +57,23 @@ export function watchPages() {
 
 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',
+		'*/backend/templates/**/*.tsx', 
+		'*/backend/templates/data/*.json', 
+		'!*/backend/templates/render.ts',
 	], gulp.parallel(
-        previewTemplatesLib(),
-        testLib(),
+        previewTemplates(taskOptions),
+        test(taskOptions),
+        checkTs(taskOptions),
         )
     );
 }
@@ -160,16 +96,10 @@ export function watchAll(options: TaskOptions) {
     return gulp.parallel(
         watchSCSS,
         watchBackend,
-        watchBackendLib,
-        watchJSW,
-        watchJSWLib,
         watchPublic,
-        watchPublicLib,
         watchPages,
-        watchFilesLib,
         watchFiles,
         watchTemplates,
-        watchTemplatesLib,
         watchTypes,
     );
 }

package/src/helpers.ts

@@ -7,6 +7,7 @@ import { spawnSync } from 'child_process';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { ModuleSettings, ProjectSettings } from '.';
+import { exec } from 'child_process';
 
 import { blue, green, orange, red } from './index.js';
 
@@ -76,4 +77,25 @@ export async function runGulp(moduleSettings: ModuleSettings, projectSettings: P
 
     // 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/src/index.ts

@@ -11,7 +11,7 @@ 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 type LucySettings = {
@@ -70,6 +70,11 @@ 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
@@ -169,6 +174,7 @@ async function main(): Promise<void> {
 
 	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/src/models.ts

@@ -0,0 +1,35 @@
+export type TSConfig = {
+    compilerOptions?: {
+        target?: string; // e.g., "ES5", "ES6", "ES2015", "ESNext"
+        module?: string; // e.g., "CommonJS", "ES6", "ESNext"
+        lib?: string[]; // e.g., ["ES2015", "DOM"]
+        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[]; // e.g., ["node", "jest"]
+        typeRoots?: string[]; // e.g., ["./types"]
+        jsx?: "preserve" | "react" | "react-jsx" | "react-jsxdev" | "react-native";
+        incremental?: boolean;
+        noEmit?: boolean;
+        paths?: Record<string, string[]>; // Aliases for module paths
+        [key: string]: any; // Allow additional compiler options
+    };
+    include?: string[]; // Glob patterns to include
+    exclude?: string[]; // Glob patterns to exclude
+    files?: string[]; // Specific files to include
+    extends?: string; // Path to a base tsconfig.json
+    references?: { path: string }[]; // Project references
+    compileOnSave?: boolean;
+    [key: string]: any; // Allow additional top-level options
+};