lucy-cli 0.0.4

package/src/gulp/types.ts

@@ -0,0 +1,87 @@
+import chalk from 'chalk';
+import gulp from 'gulp';
+import { createGulpEsbuild } from 'gulp-esbuild';
+import rename from 'gulp-rename';
+import * as path from 'path';
+import { File, TaskOptions } from '../Gulpfile';
+import clean from 'gulp-clean';
+import replace from 'gulp-string-replace';
+import foreach from 'gulp-foreach';
+import jeditor from 'gulp-json-editor';
+import merge from 'merge-stream';
+import * as insert from 'gulp-insert';
+
+export function updateWixTypes(options: TaskOptions) {
+	const { publicSettings, backendSettings, masterSettings, pageSettings, replaceOpions } = options;
+	let count = 0;
+    return () => {
+		return gulp.src(['./.wix/types/*/*.json', '!./.wix/types/wix-code-types/*.json'])
+		.pipe(foreach(function(stream: NodeJS.ReadableStream, file: File) {
+			count ++;
+			if (file.dirname.endsWith('public')) return stream.pipe(jeditor(publicSettings));
+			if (file.dirname.endsWith('backend')) return stream.pipe(jeditor(backendSettings));
+			if (file.dirname.endsWith('masterPage')) return stream.pipe(jeditor(masterSettings));
+			
+			return stream.pipe(jeditor(pageSettings));
+		}))
+		.pipe(replace('masterPage.masterPage.js', 'masterPage.ts', replaceOpions))
+		.pipe(replace('/src/', '/typescript/', replaceOpions))
+		.pipe(replace('.js"', '.ts"', replaceOpions))
+		// .pipe(tap(function(file) { // tap into the stream to log the output
+		// 	console.log(file.contents?.toString() ?? 'no content');
+		// }))
+		.pipe(gulp.dest((file: File) => {
+			const filePath = file.dirname;
+			const outputDir = path.dirname(filePath);
+	
+			return path.join(outputDir);
+		}))
+		.on('error', function () {
+			console.log(chalk.red.underline.bold('Modification of WIX configs failed!'));
+			this.emit('end');
+		})
+		.on('end', function() { console.log(chalk.blueBright.underline(`Modification of ${count} WIX configs succeeded!`)); });	  
+    }
+}
+
+
+export function addTypes(options: TaskOptions, done: gulp.TaskFunctionCallback): NodeJS.ReadWriteStream {
+	const { replaceOpions, cwd } = options;
+	console.log('CWD', cwd);
+	const processPages = gulp.src(['./.wix/types/wix-code-types/dist/types/page/$w.d.ts'])
+		.pipe(replace('declare namespace \\$w {', ' declare namespace $w{\nconst api: $w.Api;\n', replaceOpions))
+		.pipe(gulp.dest('./.wix/types/wix-code-types/dist/types/page/'));
+
+	const exportTypes = 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('interface ', 'export interface ', replaceOpions))
+		.pipe(replace('enum ', 'export enum ', replaceOpions))
+		.pipe(replace('type ', 'export type ', replaceOpions))
+		.pipe(gulp.dest('./.wix/types/wix-code-types/dist/types/common/'));
+
+	const exportTypesBeta = 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('interface ', 'export interface ', replaceOpions))
+		.pipe(replace('enum ', 'export enum ', replaceOpions))
+		.pipe(replace('type ', 'export type ', replaceOpions))
+		.pipe(gulp.dest('./.wix/types/wix-code-types/dist/types/beta/common/'));
+
+	const processCommon = gulp.src(['./.wix/types/wix-code-types/dist/types/common/$w.d.ts'])
+		.pipe(insert.prepend("import { FrontendAPISchema } from '../../../../../../typescript/public/models/common/frontendApi.model';\nimport '@total-typescript/ts-reset';\n"))
+		.pipe(replace('namespace \\$w {', 'declare namespace $w{\ntype Api = FrontendAPISchema;\n', replaceOpions))
+		.pipe(gulp.dest('./.wix/types/wix-code-types/dist/types/common/'));
+
+	return merge(
+		processPages,
+		processCommon,
+		exportTypesBeta,
+		exportTypes,
+	)
+	.on('error', function() {
+		console.log(chalk.red.underline.bold('Add of new Types (store & Global) failed!'));
+		this.emit('end');
+		done();
+	})
+	.on('end', function() {
+		console.log(chalk.blueBright.underline('Add of new Types (store & Global) succeeded!'));
+		done();
+	});
+};

package/src/index.ts

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { spawnSync } from 'child_process';
+import { existsSync, mkdirSync, promises as fsPromises } from 'fs';
+import chalk from 'chalk';
+import settings from './settings.json' assert { type: 'json' };
+
+import { join } from 'path';
+import fs from 'fs/promises';
+
+import { init } from './init.js';
+import { dev } from './dev.js';
+
+type ModuleSettings = {
+	packageRoot: string;
+	targetFolder: string;
+	args: string[];
+	wixConfigPath: string;
+	lucyConfigPath: string;
+}
+
+type ProjectSettings = {
+	packages?: Record<string, string>;
+	modules?: Record<string, string>;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const __filename = fileURLToPath(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const __dirname = dirname(__filename);
+
+
+
+/**
+ *
+ */
+async function main() {
+
+	const moduleSettings: ModuleSettings = {
+		packageRoot: dirname(__dirname),
+		targetFolder: process.cwd(),
+		args:  process.argv.slice(2),
+		wixConfigPath: join(process.cwd(), 'wix.config.json'),
+		lucyConfigPath: join(process.cwd(), 'lucy.json')
+	}
+
+	let projectSettings: ProjectSettings | undefined; 
+
+	if (!existsSync(moduleSettings.wixConfigPath)) {
+		console.log(chalk.red.underline.bold(`This is not a WIX project ${moduleSettings.targetFolder}`));
+		return;
+    }
+
+	const packageJSONraw = await fs.readFile(join(moduleSettings.targetFolder, 'package.json'), 'utf8');
+	const packageJSON = JSON.parse(packageJSONraw);
+
+	if(existsSync(moduleSettings.lucyConfigPath)) {
+		try {
+			const data = await fs.readFile(moduleSettings.lucyConfigPath, 'utf8');
+			projectSettings = JSON.parse(data);
+		} catch (parseError) {
+			console.error(chalk.red.underline.bold('Error parsing Lucy.json', parseError));
+		}
+	} else {
+		console.log(chalk.blueBright.underline.bold('Project not Intialized!'));
+		return;
+	}
+
+
+
+	if(packageJSON?.wixLucy?.intialized && ! args.includes('-f')) {
+		console.error(chalk.red.underline.bold(`This project is already initialized ${moduleSettings.targetFolder}`));
+		return;
+	}
+
+	console.log({ args, cwd });
+	if(args.includes('help') || args.includes('-h')){
+		console.log('Help is on the way!');
+        
+		return;
+	}
+	if(args.includes('version') || args.includes('-v')){
+		console.log('1.0.0');
+        
+		return;
+	}
+    
+	if(args.includes('init')){
+		init(cwd, packageRoot, args);
+		
+		return;
+	}
+
+	if(args.includes('dev')){
+		dev(cwd, args);
+		
+		return;
+	}
+
+	if(args.includes('sync')){
+		console.log('Hello serve');
+
+		return;
+	}
+
+}
+
+main();
+
+// const fs = require("fs"),
+//     path = require("path")
+
+// /** Parse the command line */
+// var args = process.argv.slice(2);
+
+// // Validate input
+// if (args.length !== 2) {
+//     console.log("Warning: Requires 2 arguments");
+//     console.log("node index.js [path/source.html] [targetfile]");
+//     process.exit();
+// }
+
+// const src = args[0];
+// const target = args[1];
+// const dirsrc = path.dirname(src);
+
+// if (!fs.existsSync(src)) {
+//     console.log("Error: Source file doesn't exist. Given: ", src);
+//     process.exit();
+// }
+

package/src/init.ts

@@ -0,0 +1,191 @@
+import chalk from 'chalk';
+import { existsSync, mkdirSync, promises as fsPromises } from 'fs';
+import fse from 'fs-extra';
+import { join } from 'path';
+import { simpleGit, SimpleGit, SimpleGitOptions } from 'simple-git';
+import fs from 'fs/promises';
+import { spawnSync } from 'child_process';
+import settings from './settings.json' assert { type: 'json' };
+import path from 'path';
+
+
+type ProjectSettings = {
+	packages?: Record<string, string>;
+	modules?: Record<string, string>;
+}
+
+/**
+ * Init Lucy project
+ * @param {string} cwd Current working directory
+ * @param {string} packageRoot Package root directory
+ * @returns {void}
+ */
+export async function init(cwd: string, packageRoot:string, args: string[]) {
+	const sourceFolder = join(packageRoot, 'files');
+	const targetFolder = cwd;
+	let projectSettings: ProjectSettings|undefined; 
+
+	if(existsSync(join(targetFolder, 'lucy.json'))) {
+		try {
+			const lucyConfig = join(targetFolder, 'lucy.json');
+			const data = await fs.readFile(lucyConfig, 'utf8');
+			projectSettings = JSON.parse(data);
+		} catch (parseError) {
+			console.error(chalk.red.underline.bold('Error parsinc Lucy.json', parseError));
+		}
+	} else {
+		const lucyConfig = {
+			packages: settings.packages,
+			modules: settings.modules
+		}
+		await fs.writeFile(join(targetFolder, 'lucy.json'), JSON.stringify(lucyConfig, null, 2), 'utf8');
+		console.log(chalk.blueBright.underline.bold('Created Lucy config file!'));
+	}
+
+    const wixConfigPath = join(targetFolder, 'wix.config.json');
+	const packageJSONraw = await fs.readFile(join(targetFolder, 'package.json'), 'utf8');
+	const packageJSON = JSON.parse(packageJSONraw);
+	
+	if(packageJSON?.wixLucy?.intialized && ! args.includes('-f')) {
+		console.error(chalk.red.underline.bold(`This project is already initialized ${targetFolder}`));
+		return;
+	}
+
+    if (!existsSync(wixConfigPath)) {
+		console.error(chalk.red.underline.bold(`This is not a WIX project ${targetFolder}`));
+		return;
+    }
+
+	await copyFolder(sourceFolder, targetFolder);
+
+	await editJson(join(targetFolder, 'package.json'), ['type', 'scripts', 'wixLucy'], ['module', settings.scripts, settings.lucySettings ]);
+	await stringReplace(join(targetFolder, 'currents.config.js'), ['__ProjectName__'], [path.basename(targetFolder)]);
+
+	await installPackages(projectSettings?.packages ? projectSettings?.packages :  settings.packages, targetFolder);
+
+	await editJson(join(targetFolder, 'jsconfig.json'), ['compilerOptions', 'exclude'], [settings.wixSettings.compilerOptions, settings.wixSettings.exclude]);
+	await editJson(join(targetFolder, 'typedoc.json'), ['name'], [path.basename(targetFolder)]);
+
+	await gitInit(targetFolder, projectSettings?.modules ? projectSettings?.modules : settings.modules);
+	console.log(chalk.blueBright.underline.bold('Done!'));
+}
+
+/**
+ * Copy files from source to target
+ * @param {string} source Source folder
+ * @param {string} target Target folder
+ * @returns {Promise<void>}
+ */
+async function copyFolder(source: string, target: string): Promise<void> {
+	if (!existsSync(target)){
+		console.error(chalk.red.underline.bold(`Target folder doesn't exist: ${target}`));
+		return;
+	}
+
+	try {
+		const files = await fsPromises.readdir(source);
+		for (const file of files){
+			const sourcePath = join(source, file);
+			const targetPath = join(target, file);
+
+			if (file === 'lucy.json' && existsSync(targetPath)){
+				continue;
+			}
+			const stats = await fsPromises.stat(sourcePath);
+			if (stats.isDirectory()){
+				if (!existsSync(file)){
+					mkdirSync(file);
+				}
+				await fse.copySync(sourcePath, targetPath, { overwrite: true });
+			} else {
+				fse.copySync(sourcePath, targetPath, { overwrite: true });
+			}
+		}
+	} catch (err){
+		console.error(chalk.red.underline.bold(err));
+	} finally {
+		console.log(chalk.blueBright.underline.bold('Copy files completed!'));
+	}
+}
+
+/**
+ * Edit Json files
+ * @param {string} filePath File path
+ * @param {string[]} keys Keys to edit
+ * @param {string[]} values Values to edit
+ * @returns {void}
+ */
+async function editJson(filePath: string, keys: string[], values: string[] | Object[] ) {
+	try {
+		const data = await fs.readFile(filePath, 'utf8');
+
+		let jsonData;
+		try {
+			jsonData = JSON.parse(data);
+		} catch (parseError) {
+			console.error(chalk.red.underline.bold('Error parsing JSON:', parseError));
+			return;
+		}
+
+		for (const key of keys){
+			const index = keys.indexOf(key);
+			const value = values[index];
+			jsonData[key] = value;
+		}
+
+		const updatedJsonData = JSON.stringify(jsonData, null, 2);
+		await fs.writeFile(filePath, updatedJsonData, 'utf8');
+	} catch (err) {
+		console.log(chalk.red.underline.bold(err));
+	} finally {
+		console.log(chalk.blueBright.underline.bold(`File ${filePath} updated successfully!`));
+	}
+}
+
+async function stringReplace(filePath: string, keys: string[], values: string[]) {
+	try {
+		let modifiedContent: string = '';
+		const data = await fs.readFile(filePath, 'utf8');
+
+		for (const key of keys){
+			const index = keys.indexOf(key);
+			const value = values[index];
+			const regex = new RegExp(`${key}`, 'g');
+			modifiedContent = data.replace(regex, `${value}`);
+		}
+
+		await fs.writeFile(filePath, modifiedContent, 'utf8');
+	} catch (err) {
+		console.log(chalk.red.underline.bold(err));
+	} finally {
+		console.log(chalk.blueBright.underline.bold(`File ${filePath} updated successfully!`));
+	}
+}
+
+async function installPackages(packages: Record<string, string>, cwd: string) {
+	const packageNames = Object.keys(packages);
+	const packageVersions = Object.values(packages);
+	const packageNamesAndVersions = packageNames.map((name, index) => `${name}@${packageVersions[index]}`);
+	const command = `yarn add ${packageNamesAndVersions.join(' ')}`;
+	const result = spawnSync(command, { shell: true, stdio: 'inherit' });
+	if (result.error) {
+		console.error(chalk.red.underline.bold(`Command failed: ${result.error.message}`));
+	} else {
+		console.log(chalk.blueBright.underline.bold(`Command succeeded: ${result.stdout}`));
+	}																
+}
+
+async function gitInit(cwd: string, modules: Record<string, string>) {
+	const git = simpleGit({ baseDir: cwd });
+	for (const [name, url] of Object.entries(modules)) {
+		console.log(chalk.green.underline.bold(`Cloning ${name}`));
+		try {
+			await git.submoduleAdd(url, name)
+		} catch (e) {
+			console.error(chalk.red.underline.bold(`Command failed: ${e}`));
+		} finally {	
+			console.log(chalk.blueBright.underline.bold(`Cloned ${name}`));
+		}
+	}
+	console.log(chalk.blueBright.underline.bold(`All Modules cloned!`));
+}

package/src/settings.json

@@ -0,0 +1,91 @@
+{
+  "modules": {
+    "wix-lucy-lib": "git@github.com:Integral-Systems/wix-lucy-lib.git"
+  },
+  "wixSettings": {
+    "compilerOptions": {
+      "composite": true,
+      "noEmit": false,
+      "lib": [
+        "DOM"
+      ],
+      "jsx": "react"
+    },
+    "exclude": [
+      "**/*.js"
+    ]
+  },
+  "lucySettings": {
+    "intialized": true,
+  },
+  "packages": {
+    "@danpercic86/helpful-decorators": "^2.4.0",
+    "@js-joda/core": "5.5.3",
+    "@js-joda/locale": "4.8.10",
+    "@js-joda/locale_de": "4.8.10",
+    "@js-joda/locale_en": "4.8.10",
+    "@js-joda/timezone": "2.18.0",
+    "@react-pdf/renderer": "2.0.17",
+    "@total-typescript/ts-reset": "^0.4.2",
+    "@types/i18n": "^0.13.6",
+    "@types/jest": "^29.5.3",
+    "@types/node": "^20.5.7",
+    "@types/nodemailer": "^6.4.10",
+    "@types/react": "^18.2.21",
+    "@typescript-eslint/eslint-plugin": "^5.61.0",
+    "@typescript-eslint/parser": "^5.61.0",
+    "@typescript-eslint/utils": "^5.61.0",
+    "@wix/cli": "1.0.83",
+    "@wix/eslint-plugin-cli": "^1.0.1",
+    "@wix/image": "1.96.0",
+    "@wix/velo-bind": "1.0.8",
+    "add": "^2.0.6",
+    "await-semaphore": "0.1.3",
+    "axios": "1.4.0",
+    "crypto-js": "4.1.1",
+    "cypress": "^12.17.2",
+    "cypress-cloud": "^1.9.3",
+    "esbuild": "^0.18.11",
+    "eslint": "^8.25.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-jsdoc": "^46.4.3",
+    "eslint-plugin-named-import-spacing": "^1.0.3",
+    "eslint-plugin-simple-import-sort": "^10.0.0",
+    "eventemitter3": "4.0.7",
+    "gsap": "3.11.4",
+    "helpful-decorators": "^2.1.0",
+    "i18next": "22.4.7",
+    "jest": "^29.6.1",
+    "merge-stream": "^2.0.0",
+    "mobx": "6.8.0",
+    "mobx-utils": "6.0.3",
+    "node-cache": "5.1.2",
+    "nodemailer": "6.9.3",
+    "payment": "2.3.0",
+    "prettier": "^3.0.3",
+    "react": "18.2.0",
+    "react-dom": "18.1.0",
+    "react-transition-group": "4.4.5",
+    "sass": "^1.65.1",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "tsx": "^3.13.0",
+    "typedoc": "^0.25.1",
+    "typedoc-theme-hierarchy": "^4.0.0",
+    "typescript": "^5.1.6",
+    "uuid": "9.0.0",
+    "zod": "3.22.2"
+  },
+  "scripts": {
+    "postinstall": "wix sync-types",
+    "wix:dev": "wix dev",
+    "dev": "gulp dev",
+    "lint": "eslint .",
+    "docs": "typedoc --tsconfig typescript/tsconfig.json --skipErrorChecking",
+    "build": "gulp build-prod",
+    "fix-wix": "gulp fix-wix",
+    "tsc": "tsc -p ./typescript/tsconfig.json --noEmit",
+    "test": "jest --config jest.config.ts --passWithNoTests",
+    "test:watch": "jest --config jest.config.ts --watch"
+  }
+}

package/src/types.d.ts

@@ -0,0 +1,5 @@
+declare module 'gulp-exec';
+declare module 'gulp-clean';
+declare module 'gulp-foreach';
+declare module 'gulp-string-replace';
+declare module 'gulp-wait';

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+    "typeAcquisition": {
+        "enable": true
+    },
+    "compilerOptions": {
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "target": "ES2020",
+        "build": true,
+        "module": "ESNext",
+        "moduleResolution": "Node",
+        "preserveConstEnums": true,
+        "allowSyntheticDefaultImports": true,
+        "skipLibCheck": true,
+        "declaration": true,
+        "strict": true,
+        "noEmitOnError": false,
+        "strictNullChecks": true,
+        "noImplicitAny": true,
+        "noImplicitReturns": true,
+        "noUncheckedIndexedAccess": true,
+        "noImplicitThis": false,
+        "strictBindCallApply": false,
+        "strictFunctionTypes": true,
+        "strictPropertyInitialization": true,
+        "experimentalDecorators": true,
+        "esModuleInterop": true,
+        "resolveJsonModule": true,
+    },
+    "exclude": ["../node_modules"],
+    "include":[
+        "src/**/*.ts"
+    ],
+}