lucy-cli 2.0.0-alpha.11 → 2.0.0-alpha.12

package/src/tasks/gulp/clean.ts

@@ -0,0 +1,38 @@
+import gulp from 'gulp';
+import { TaskOptions } from '../Gulpfile.js';
+import clean from 'gulp-clean';
+import { logger } from '../../utils/logger.js';
+
+export function cleanWix() {	
+    return () => {
+        return gulp.src('./.wix', { read: false, allowEmpty: true })
+		.pipe(clean({ force: true }))
+		.on('error', function (e: Error) {
+			logger.error('Cleaning of .wix failed!');
+			logger.error(`Error: ${e.message}`);
+
+
+			this.emit('end');
+		})
+		.on('end', function() { 
+			logger.success("Cleaning of .wix succeeded!");
+		});
+    }
+}
+
+export function cleanSrc(options: TaskOptions) {
+	const { outputDir } = options;
+
+	return () => {
+		return gulp.src([`${outputDir}/pages`, `${outputDir}/public`, `${outputDir}/backend`], { read: false, allowEmpty: true })
+		.pipe(clean({ force: true }))
+		.on('error', function (e: Error) {
+			logger.error('Cleaning of output files failed!');
+			logger.error(` => Error: ${e.message}`);
+			this.emit('end');
+		})
+		.on('end', function() {
+			logger.success('Cleaning of .src succeeded!');
+		});
+	}
+}

package/src/tasks/gulp/copy.ts

@@ -0,0 +1,43 @@
+import gulp from 'gulp';
+import { TaskOptions } from '../Gulpfile.js';
+import { logger } from '../../utils/logger.js';
+
+export function copyFiles(options: TaskOptions) {
+    const folders = ['typescript', ...options.modulesSourcePaths];
+
+    // 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 (e: Error) {
+                    logger.error(` => Copy of files for ${folder} failed!`);
+                    logger.error(` => Error: ${e.message}`);
+
+                    
+                    this.emit('end');
+                })
+                .on('end', function () {
+                    logger.success(` => Copy of files for ${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/tasks/gulp/helpers.ts

@@ -0,0 +1,25 @@
+
+// import * as path from 'path';
+// import * as fs from 'fs';
+import { LucyConfig } from '../../config.js';
+
+// 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;
+// }
+
+export function getModulesSourcePaths(config: LucyConfig): string[] {
+    const data =  config.lucySettings.modules;
+    const paths: string[] = [];
+    for (const module of Object.keys(data)) {
+        if (!data[module].noCompile) {
+            if (data[module].path) {
+                paths.push(data[module].path);
+            } else {
+                paths.push(module);
+            }
+        }
+    }
+    return paths;
+}

package/src/tasks/gulp/pages.ts

@@ -0,0 +1,43 @@
+import gulp from 'gulp';
+import { TaskOptions } from '../Gulpfile.js';
+import * as path from 'path';
+import swc from 'gulp-swc';
+import { logger } from '../../utils/logger.js';
+
+const swcOptions = {
+    jsc: {
+        target: 'es2020',
+        parser: {
+            syntax: "typescript",
+            tsx: true,
+        },
+        preserveAllComments: false,
+        minify: {
+            compress: true // equivalent to {}
+        }
+    },
+};
+
+export function buildPages(options: TaskOptions) {
+    const { outputDir} = options;
+
+    return () => {
+        return gulp.src('typescript/pages/*.ts')
+            .pipe(swc(swcOptions))
+                .on('error', function (e: Error) {
+                    logger.error('Build of Pages files failed!');
+                    logger.error(`Error: ${e.message}`);
+
+                    this.emit('end');
+                })
+                .pipe(gulp.dest(path.join(outputDir, 'pages')))
+                .on('error', function (e: Error) {
+                    logger.error('Build of Pages TS files failed!');
+                    logger.error(`Error: ${e.message}`);
+                    this.emit('end');
+                })
+                .on('end', function() {
+                    logger.success('Build of Pages TS files succeeded!');
+                });
+    };
+}

package/src/tasks/gulp/pipeline.ts

@@ -0,0 +1,32 @@
+import gulp from 'gulp';
+import * as path from 'path';
+import { File } from '../Gulpfile.js';
+import replace from 'gulp-string-replace';
+import { logger } from '../../utils/logger.js';
+
+export function setProdConfig() {
+    const tag = process.env.GIT_TAG || 'development';
+    const regexGit = /gitTag:\s*(.*),/g;
+    const regexDev = /devMode:\s*(.*),/g;
+
+    return () => {
+        return gulp
+            .src(['./typescript/public/constants/env.ts']) 
+            .pipe(replace(regexGit, `gitTag: '${tag}',`))
+            .pipe(replace(regexDev, `devMode: false,`))
+            .pipe(gulp.dest((file: File) => {
+                const filePath = file.dirname;
+                const outputDir = path.dirname(filePath);
+        
+                return path.join(`${outputDir}/constants`);
+            }))
+            .on('error', function (e: Error) {
+                logger.error(' => Setting the git tag failed!');
+                logger.error(` => Error: ${e.message}`);
+                this.emit('end');
+            })
+            .on('end', function() {
+                logger.success(' => Setting the git tag succeeded!');
+            });
+    }
+}

package/src/tasks/gulp/public.ts

@@ -0,0 +1,60 @@
+import gulp from 'gulp';
+import * as path from 'path';
+import { TaskOptions } from '../Gulpfile.js';
+import swc from 'gulp-swc';
+import { logger } from '../../utils/logger.js';
+
+const swcOptions = {
+    jsc: {
+        target: 'es2020',
+        parser: {
+            syntax: "typescript",
+            tsx: true,
+        },
+        preserveAllComments: false,
+        minify: {
+            compress: true // equivalent to {}
+        }
+    },
+};
+
+export function buildPublic(options: TaskOptions) {
+    const folders = ['typescript', ...options.modulesSourcePaths];
+
+    const { outputDir } = options;
+
+    // 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(swc(swcOptions))
+                .on('error', function (e: Error) {
+                    logger.error(` => Build of Public files for ${folder} failed!`);
+                    logger.error(` => Error: ${e.message}`);
+
+                    this.emit('end');
+                })
+                .pipe(gulp.dest(path.join(outputDir, 'public')))
+                .on('error', function (e: Error) {
+                    logger.error(` => Build of Public files for ${folder} failed!`);
+                    logger.error(` => Error: ${e.message}`);
+                    this.emit('end');
+                })
+                .on('end', function () {
+                    logger.success(` => Build of Public files for ${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/tasks/gulp/styles.ts

@@ -0,0 +1,46 @@
+import gulp from 'gulp';
+import chalk from 'chalk';
+import { TaskOptions } from '../Gulpfile.js';
+import { logger, orange } from '../../utils/logger.js';
+
+export function compileScss(options: TaskOptions) {
+    const folders = ['typescript'];
+
+    const { sass, outputDir} = options;
+
+    const buildWixScss =  () => gulp.src(['typescript/styles/global.scss'], { allowEmpty: true })
+        .pipe(sass().on('error', sass.logError))
+        .on('error', function (e: Error) {
+            logger.error(` => Build of SCSS files for ${orange('global.scs')} failed!`);
+            logger.error(` => Error: ${orange(e.message)}`);
+            this.emit('end');
+        })
+        .pipe(gulp.dest(`${outputDir}/styles`))
+        .on('error', function (e: Error) {
+            logger.error(` => Compiling of scss files for ${orange('global.scs')} failed!`);
+            logger.error(` => Error: ${orange(e.message)}`);
+            this.emit('end');
+        })
+        .on('end', function () {
+            logger.success(` => Compiling of scss files for ${orange('global.scs')} succeeded!`);
+        });
+
+    const buildScss =  () => gulp.src(['typescript/public/scss/app.scss'], { allowEmpty: true })
+        .pipe(sass().on('error', sass.logError))
+        .on('error', function (e: Error) {
+            logger.error(` => Build of SCSS files for ${orange('app.scss')} failed!`);
+            logger.error(` => Error: ${orange(e.message)}`);
+            this.emit('end');
+        })
+        .pipe(gulp.dest(`${outputDir}/public/css`))
+        .on('error', function (e: Error) {
+            logger.error(` => Compiling of scss files for ${orange('app.scss')} failed!`);
+            logger.error(` => Error: ${orange(e.message)}`);
+            this.emit('end');
+        })
+        .on('end', function () {
+            logger.success(` => Compiling of scss files for ${orange('app.scss')} succeeded!`);
+        });
+        
+    return gulp.parallel(buildWixScss, buildScss);
+}

package/src/tasks/gulp/templates.ts

@@ -0,0 +1,53 @@
+import gulp from 'gulp';
+import { File, TaskOptions } from '../Gulpfile.js';
+import exec from 'gulp-exec';
+import { logger, orange } from '../../utils/logger.js';
+import path from 'path';
+import fs from 'fs';
+
+export function previewTemplates(options: TaskOptions) {
+        const allFolders = ['typescript', ...options.modulesSourcePaths];
+        
+        // Filter folders to only include those that have a 'backend/templates' directory
+        const foldersWithTemplates = allFolders.filter(folder => {
+            const templateDir = path.join(folder, 'backend', 'templates');
+            return fs.existsSync(templateDir);
+        });
+
+        if (foldersWithTemplates.length === 0) {
+            logger.info("No template folders found to preview.");
+            // Return a Gulp task that does nothing.
+            return (done: () => void) => done();
+        }
+
+        const taskOpt = {
+            continueOnError: true,
+        };
+    
+        // Create tasks for each folder that has a template directory
+        const tasks = foldersWithTemplates.map((folder) => {
+            const taskName = `render_templates-${folder}`;
+            const task = () =>
+                gulp.src([
+                    `${folder}/backend/templates/**/*.tsx`, 
+                    `${folder}/backend/templates/data/*.json`, 
+                    `!${folder}/backend/templates/render.ts`,
+                ])
+                .pipe(exec((file: File) => `npx tsx --tsconfig ./local.tsconfig.json ${file.path}`, taskOpt))
+                    .on('error', function (e: Error) {
+                        logger.error(` => Render of Template for ${orange(folder)} failed!`);
+                        logger.error(` => Error: ${orange(e.message)}`);
+                        this.emit('end');
+                    })
+                    .on('end', function () {
+                        logger.success(` => 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/src/tasks/gulp/types.ts

@@ -0,0 +1,317 @@
+import gulp from 'gulp';
+import * as path from 'path';
+import { File, TaskOptions } from '../Gulpfile.js';
+import replace from 'gulp-string-replace';
+import flatmap from 'gulp-flatmap';
+import jeditor from 'gulp-json-editor';
+import * as insert from 'gulp-insert';
+import tap from 'gulp-tap';
+import { TSConfig } from '../../schemas/tsconfig.js';
+import { logger, orange, yellow } from '../../utils/logger.js';
+
+export function updateWixTypes(options: TaskOptions) {
+    return () => {
+		const { publicSettings, backendSettings, masterSettings, pageSettings, replaceOptions } = options;
+		let count = 0;
+		
+		const modules: Record<string, string>  = Object.assign({}, options.projectSettings?.modules, options.projectSettings?.lucySettings?.modules);
+
+		let localModules: Record<string, string> | undefined = undefined;
+		if(options.projectSettings?.lucySettings) {
+			localModules = options.projectSettings.lucySettings.modules as unknown as Record<string, string>;
+		}
+		// Add module to publicSettings
+		publicSettings.compilerOptions.paths['backend/*.web'] = [ "../../../typescript/backend/*.web.ts" ] as never;
+		publicSettings.compilerOptions.paths['backend/*.web.js'] = [ "../../../typescript/backend/*.web.ts" ] as never;
+		publicSettings.compilerOptions.paths['backend/*'] = [ "../../../typescript/backend/*.web.ts" ] as never;
+		publicSettings.compilerOptions.paths['backend/*.jsw'] = [ "../../../typescript/backend/*.jsw.ts" ] as never;
+		publicSettings.compilerOptions.paths.mocks = [ "../../../typescript/__mocks__/*" ] as never;
+		publicSettings.compilerOptions.paths['types/*'] = [ "../../../typescript/types/*" ] as never;
+		publicSettings.compilerOptions.paths['public/*'] = [ "../../../typescript/public/*.ts" ] as never;
+		publicSettings.include = [ 
+			"../../../typescript/public/**/*", 
+			"../../../typescript/__mocks__/**/*", 
+			// "../../../typescript/backend/**/*.jsw.ts",
+			// "../../../typescript/backend/**/*.web.ts",
+			// "../../../typescript/backend/**/*.web"
+		] as never;
+
+		// Add module to backendSettings
+		backendSettings.compilerOptions.paths.mocks = [ "../../../typescript/__mocks__/*" ] as never;
+		backendSettings.compilerOptions.paths['types/*'] = [ `../../../typescript/types/*` ] as never;
+		backendSettings.include = [ 
+			"../../../typescript/backend/**/*", 
+			"../../../typescript/__mocks__/**/*",
+			// "../../../typescript/backend/**/*.jsw.ts",
+			// "../../../typescript/backend/**/*.web.ts",
+			// "../../../typescript/backend/**/*.web"
+		] as never;	
+		// Add module to masterSettings
+		masterSettings.compilerOptions.paths['backend/*.web'] = [ "../../../typescript/backend/*.web.ts" ] as never;
+		masterSettings.compilerOptions.paths['backend/*.web.js'] = [ "../../../typescript/backend/*.web.ts" ] as never;
+		masterSettings.compilerOptions.paths['backend/*'] = [ "../../../typescript/backend/*.web.ts" ] as never;
+		masterSettings.compilerOptions.paths['backend/*.jsw'] = [ "../../../typescript/backend/*.jsw.ts" ] as never;
+		masterSettings.compilerOptions.paths['types/*'] = [ "../../../typescript/types/*" ] as never;
+		masterSettings.include = [ 
+			"../../../typescript/public/**/*", 
+			"../../../typescript/__mocks__/**/*", 
+			// "../../../typescript/backend/**/*.jsw.ts",
+			// "../../../typescript/backend/**/*.web.ts",
+			// "../../../typescript/backend/**/*.web"
+		] as never;
+		// Add module to pageSettings
+		pageSettings.compilerOptions.paths['backend/*.web'] = [ "../../../typescript/backend/*.web.ts" ] as never;
+		pageSettings.compilerOptions.paths['backend/*.web.js'] = [ "../../../typescript/backend/*.web.ts" ] as never;
+		pageSettings.compilerOptions.paths['backend/*'] = [ "../../../typescript/backend/*.web.ts" ] as never;
+		pageSettings.compilerOptions.paths['backend/*.jsw'] = [ "../../../typescript/backend/*.jsw.ts" ] as never;
+		pageSettings.compilerOptions.paths['types/*'] = [ "../../../typescript/types/*" ] as never;
+		pageSettings.compilerOptions.paths['backend/*.jsw'] = [ "../../../typescript/backend/*.jsw.ts" ] as never;
+		pageSettings.include = [ 
+			"../../../typescript/public/**/*", 
+			"../../../typescript/__mocks__/**/*", 
+			// "../../../typescript/backend/**/*.jsw.ts",
+			// "../../../typescript/backend/**/*.web.ts",
+			// "../../../typescript/backend/**/*.web"
+		] as never;
+
+		if (modules) {
+			for (const [name] of Object.entries(modules)) {
+				// Add module to publicSettings
+				publicSettings.compilerOptions.paths['backend/*.web.js'].push(`../../../${name}/backend/*.web.ts` as never);
+				publicSettings.compilerOptions.paths['backend/*.web'].push(`../../../${name}/backend/*.web.ts` as never);
+				publicSettings.compilerOptions.paths['backend/*'].push(`../../../${name}/backend/*.web.ts` as never);
+				publicSettings.compilerOptions.paths['backend/*.jsw'].push(`../../../${name}/backend/*.jsw.ts` as never);
+				publicSettings.compilerOptions.paths['public/*'].push(`../../../${name}/public/*` as never);
+				publicSettings.compilerOptions.paths.mocks.push(...[ `../../../${name}/__mocks__/*` as never ]);
+				publicSettings.compilerOptions.paths['types/*'].push(`../../../${name}/types/*` as never);
+				publicSettings.include.push(...[
+					`../../../${name}/public/**/*`, 
+					`../../../${name}__mocks__/**/*`, 
+					// `../../../${name}/backend/**/*.jsw.ts`,
+					// `../../../${name}/backend/**/*.web.ts`,
+					// `../../../${name}/backend/**/*.web`
+				] as never[]);
+				// Add module to backendSettings
+				backendSettings.compilerOptions.paths['public/*'].push(`../../../${name}/public/*` as never);
+				backendSettings.compilerOptions.paths['backend/*'].push(`../../../${name}/backend/*` as never);
+				backendSettings.compilerOptions.paths.mocks.push(...[ `../../../${name}/__mocks__/*` ] as never[]);
+				backendSettings.compilerOptions.paths['types/*'].push(`../../../${name}/types/*` as never);
+				backendSettings.include.push(...[
+					`../../../${name}/public/**/*`, 
+					`../../../${name}__mocks__/**/*`, 
+					`../../../${name}/backend/**/*`,
+					// `../../../${name}/backend/**/*.jsw.ts`,
+					// `../../../${name}/backend/**/*.web.ts`,
+					// `../../../${name}/backend/**/*.web`
+				] as never[]);
+				// Add module to masterSettings
+				masterSettings.compilerOptions.paths['backend/*.web.js'].push(`../../../${name}/backend/*.web.ts` as never);
+				masterSettings.compilerOptions.paths['backend/*.web'].push(`../../../${name}/backend/*.web.ts` as never);
+				masterSettings.compilerOptions.paths['backend/*'].push(`../../../${name}/backend/*.web.ts` as never);
+				masterSettings.compilerOptions.paths['backend/*.jsw'].push(`../../../${name}/backend/*.jsw.ts` as never);
+				masterSettings.compilerOptions.paths['public/*'].push(`../../../${name}/public/*` as never);
+				masterSettings.compilerOptions.paths['types/*'].push(`../../../${name}/types/*` as never);
+				masterSettings.include.push(...[
+					`../../../${name}/public/**/*`, 
+					`../../../${name}__mocks__/**/*`, 
+					// `../../../${name}/backend/**/*.jsw.ts`,
+					// `../../../${name}/backend/**/*.web.ts`,
+					// `../../../${name}/backend/**/*.web`
+				] as never[]);
+				// Add module to pageSettings
+				pageSettings.compilerOptions.paths['backend/*.web.js'].push(`../../../${name}/backend/*.web.ts` as never);
+				pageSettings.compilerOptions.paths['backend/*.web'].push(`../../../${name}/backend/*.web.ts` as never);
+				pageSettings.compilerOptions.paths['backend/*'].push(`../../../${name}/backend/*.web.ts` as never);
+				pageSettings.compilerOptions.paths['backend/*.jsw'].push(`../../../${name}/backend/*.jsw.ts` as never);
+				pageSettings.compilerOptions.paths['public/*'].push(`../../../${name}/public/*` as never);
+				pageSettings.compilerOptions.paths['types/*'].push(`../../../${name}/types/*` as never);
+				pageSettings.include.push(...[
+					`../../../${name}/public/**/*`, 
+					`../../../${name}__mocks__/**/*`, 
+					// `../../../${name}/backend/**/*.jsw.ts`,
+					// `../../../${name}/backend/**/*.web.ts`,
+					// `../../../${name}/backend/**/*.web`
+				] as never[]);
+			}
+		}
+
+		return gulp.src(['./.wix/types/**/*.json', '!./.wix/types/wix-code-types/**/*'])
+		.pipe(flatmap(function(stream: NodeJS.ReadableStream, file: File) {
+			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));
+			}
+			if (file.dirname.endsWith('backend')) {
+				return stream.pipe(jeditor(backendSettings))
+					.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));
+		}))
+		.pipe(replace('masterPage.masterPage.js', 'masterPage.ts', replaceOptions))
+		.pipe(replace('/src/', '/typescript/', replaceOptions))
+		.pipe(replace('.js"', '.ts"', replaceOptions))
+		.pipe(tap(function(file) { // tap into the stream to log the output
+			// console.debug(file.contents?.toString() ?? 'no content'); TODO: Uncomment when needed
+		}))
+		.pipe(gulp.dest((file: File) => {
+			const filePath = file.dirname;
+			const outputDir = path.dirname(filePath);
+	
+			return path.join(outputDir);
+		}))
+		.on('error', function (e: Error) {
+			logger.error('Modification of WIX configs failed!');
+			logger.error(` => Error: ${orange(e.message)}`);
+			this.emit('end');
+		})
+		.on('end', function() { logger.success(`Modification of ${yellow(count)} WIX configs succeeded!`); });
+    }
+}
+
+export function addTypes(options: TaskOptions, done: gulp.TaskFunctionCallback) {
+    const { replaceOptions } = options;
+
+    // Regex to match keywords at the beginning of a line, capturing any leading whitespace.
+    // The 'm' flag is for multiline matching (^ matches start of line).
+    // The 'g' flag is for global matching (replace all instances).
+    const interfaceRegex = /^(\s*)interface\s/gm;
+    const enumRegex = /^(\s*)enum\s/gm;
+    const typeRegex = /^(\s*)type\s/gm;
+
+    const streams = [
+        // Stream for common types
+        gulp.src(['./.wix/types/wix-code-types/dist/types/common/*.d.ts', '!./.wix/types/wix-code-types/dist/types/common/$w.d.ts'])
+            .pipe(replace(interfaceRegex, 'export interface ', replaceOptions))
+            .pipe(replace(enumRegex, 'export enum ', replaceOptions))
+            .pipe(replace(typeRegex, 'export type ', replaceOptions))
+            .pipe(gulp.dest('./.wix/types/wix-code-types/dist/types/common/')),
+
+        // Stream for beta types
+        gulp.src(['./.wix/types/wix-code-types/dist/types/beta/common/*.d.ts', '!./.wix/types/wix-code-types/dist/types/beta/common/$w.d.ts'])
+            .pipe(replace(interfaceRegex, 'export interface ', replaceOptions))
+            .pipe(replace(enumRegex, 'export enum ', replaceOptions))
+            .pipe(replace(typeRegex, 'export type ', replaceOptions))
+            .pipe(gulp.dest('./.wix/types/wix-code-types/dist/types/beta/common/')),
+
+        // Stream for processing $w.d.ts
+        gulp.src(['./.wix/types/wix-code-types/dist/types/common/$w.d.ts'])
+            .pipe(insert.prepend("import '@total-typescript/ts-reset';\n"))
+            .pipe(gulp.dest('./.wix/types/wix-code-types/dist/types/common/'))
+    ];
+
+    let completedStreams = 0;
+    let hasErrored = false;
+
+    streams.forEach(stream => {
+        stream.on('end', () => {
+            completedStreams++;
+            if (completedStreams === streams.length && !hasErrored) {
+                logger.success(' => Updating WIX succeeded!');
+                done();
+            }
+        });
+        stream.on('error', (e: Error) => {
+            if (!hasErrored) {
+                hasErrored = true;
+                logger.error(' => Updating WIX failed!');
+                logger.error(` => Error: ${orange(e.message)}`);
+                done(e);
+            }
+        });
+    });
+};
+function makeHashable(obj: any): any {
+    if (Array.isArray(obj)) {
+        return obj.map(makeHashable);
+    } else if (obj && typeof obj === 'object') {
+        const sortedKeys = Object.keys(obj).sort();
+        const result: any = {};
+        for (const key of sortedKeys) {
+            result[key] = makeHashable(obj[key]);
+        }
+        return result;
+    } else {
+        return obj;
+    }
+}
+
+function removeDuplicatesFromArray(arr: any[]): any[] {
+    const seen = new Set<string>();
+    const newArr: any[] = [];
+
+    for (const item of arr) {
+        const processedItem = processJson(item); // Recursively process the item
+        const hashableItem = makeHashable(processedItem);
+        const serializedItem = JSON.stringify(hashableItem);
+
+        if (!seen.has(serializedItem)) {
+            seen.add(serializedItem);
+            newArr.push(processedItem);
+        }
+    }
+    return newArr;
+}
+
+function processJson(obj: any): any {
+    if (Array.isArray(obj)) {
+        // Process arrays and remove duplicate items
+        const uniqueArray = removeDuplicatesFromArray(obj);
+        return uniqueArray.length > 0 ? uniqueArray : undefined; // Remove empty arrays
+    } else if (obj && typeof obj === 'object') {
+        // Process objects, ensuring keys are unique
+        const result: any = {};
+        const seenKeys = new Set<string>();
+
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                if (!seenKeys.has(key)) {
+                    const processedValue = processJson(obj[key]);
+                    if (processedValue !== undefined) { // Remove keys with undefined values
+                        seenKeys.add(key);
+                        result[key] = processedValue;
+                    }
+                }
+            }
+        }
+
+        // If all keys were empty or undefined, return undefined
+        return Object.keys(result).length > 0 ? result : undefined;
+    } else {
+        // Return primitive values as-is
+        return obj;
+    }
+}
+
+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;
+}