lucy-cli 0.0.4 → 0.5.0

package/dist/gulp/public.js

@@ -1,7 +1,7 @@
-import chalk from 'chalk';
 import gulp from 'gulp';
 import { createGulpEsbuild } from 'gulp-esbuild';
 import * as path from 'path';
+import { blue, red } from '../index.js';
 export function buildPublic(options) {
     const { outputDir, enableIncrementalBuild } = options;
     const gulpEsbuild = createGulpEsbuild({
@@ -14,14 +14,17 @@ export function buildPublic(options) {
         ])
             .pipe(gulpEsbuild({
             bundle: false,
+            loader: {
+                '.tsx': 'tsx',
+            },
         }))
             .pipe(gulp.dest(path.join(outputDir, 'public')))
             .on('error', function () {
-            console.log(chalk.red.underline.bold('Build of Public TS files failed!'));
+            console.log("💩" + red.underline.bold(' => Build of Public TS files failed!'));
             this.emit('end');
         })
             .on('end', function () {
-            console.log(chalk.blueBright.underline('Build of Public TS files succeeded!'));
+            console.log("🐶" + blue.underline(' => Build of Public TS files succeeded!'));
         });
     };
 }
@@ -32,19 +35,22 @@ export function buildPublicLib(options) {
     });
     return () => {
         return gulp.src([
-            'wix-lucy-lib/src/public/**/*.ts',
-            'wix-lucy-lib/src/public/**/*.tsx'
+            'lucy-lib/public/**/*.ts',
+            'lucy-lib/public/**/*.tsx'
         ])
             .pipe(gulpEsbuild({
             bundle: false,
+            loader: {
+                '.tsx': 'tsx',
+            },
         }))
             .pipe(gulp.dest(path.join(outputDir, 'public')))
             .on('error', function () {
-            console.log(chalk.red.underline.bold('Build of Public (LIB) TS files failed!'));
+            console.log("💩" + red.underline.bold(' => Build of Public (LIB) TS files failed!'));
             this.emit('end');
         })
             .on('end', function () {
-            console.log(chalk.blueBright.underline('Build of Public (LIB) TS files succeeded!'));
+            console.log("🐶" + blue.underline(' => Build of Public (LIB) TS files succeeded!'));
         });
     };
 }

package/dist/gulp/styles.js

@@ -1,17 +1,17 @@
 import gulp from 'gulp';
-import chalk from 'chalk';
+import { blue, red } from '../index.js';
 export function compileScss(options) {
     const { sass, outputDir } = options;
     return () => {
         return gulp.src(['typescript/styles/global.scss'])
             .pipe(sass().on('error', sass.logError))
-            .pipe(gulp.dest(`${outputDir}/public/css`))
+            .pipe(gulp.dest(`${outputDir}/styles`))
             .on('error', function () {
-            console.log(chalk.red.underline.bold('Compiling of scss files failed!'));
+            console.log("💩" + red.underline.bold(' => Compiling of scss files failed!'));
             this.emit('end');
         })
             .on('end', function () {
-            console.log(chalk.blueBright.underline('Compiling of scss files succeeded!'));
+            console.log("🐶" + blue.underline(' => Compiling of scss files succeeded!'));
         });
     };
 }

package/dist/gulp/templates.d.ts

@@ -1 +1,2 @@
 export declare function previewTemplates(): () => any;
+export declare function previewTemplatesLib(): () => any;

package/dist/gulp/templates.js

@@ -1,6 +1,6 @@
 import gulp from 'gulp';
-import chalk from 'chalk';
 import exec from 'gulp-exec';
+import { blue, red } from '../index.js';
 export function previewTemplates() {
     const options = {
         continueOnError: true,
@@ -13,9 +13,27 @@ export function previewTemplates() {
         ])
             .pipe(exec((file) => `npx ts-node-esm -T ${file.path}`, options))
             .on('error', function () {
-            console.log(chalk.red.underline.bold('Render of Template failed!'));
+            console.log("💩" + red.underline.bold(' => Render of Template failed!'));
             this.emit('end');
         })
-            .on('end', function () { console.log(chalk.blueBright.underline('Render of Template succeeded!')); });
+            .on('end', function () { console.log("🐶" + blue.underline(' => Render of Template succeeded!')); });
+    };
+}
+export function previewTemplatesLib() {
+    const options = {
+        continueOnError: true,
+    };
+    return () => {
+        return gulp.src([
+            'lucy-lib/backend/templates/**/*.tsx',
+            'lucy-lib/backend/templates/data/*.json',
+            '!lucy-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!')); });
     };
 }

package/dist/gulp/test.d.ts

@@ -0,0 +1,2 @@
+export declare function test(): () => any;
+export declare function testLib(): () => any;

package/dist/gulp/test.js

@@ -0,0 +1,82 @@
+import gulp from 'gulp';
+import { blue, red } from '../index.js';
+import gulpJest from 'gulp-jest';
+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 testLib() {
+    return () => {
+        return gulp.src([
+            'lucy-lib/backend/**/*.spec.ts',
+        ])
+            .pipe(jest({
+            verbose: true,
+            extensionsToTreatAsEsm: ['.ts'],
+            transform: {
+                '^.+\\.tsx?$': [
+                    'ts-jest',
+                    {
+                        tsconfig: './lucy-lib/tsconfig.json',
+                        usESM: true,
+                    },
+                ],
+            },
+            preset: 'ts-jest',
+            setupFilesAfterEnv: [],
+            testEnvironment: 'node',
+            collectCoverage: true,
+            passWithNoTests: true,
+            coverageDirectory: './coverage',
+            coverageReporters: ['clover', 'json', 'lcov', 'text'],
+            rootDir: './lucy-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!'));
+        });
+    };
+}

package/dist/gulp/types.js

@@ -1,4 +1,3 @@
-import chalk from 'chalk';
 import gulp from 'gulp';
 import * as path from 'path';
 import replace from 'gulp-string-replace';
@@ -6,6 +5,7 @@ import foreach from 'gulp-foreach';
 import jeditor from 'gulp-json-editor';
 import merge from 'merge-stream';
 import * as insert from 'gulp-insert';
+import { blue, red, yellow } from '../index.js';
 export function updateWixTypes(options) {
     const { publicSettings, backendSettings, masterSettings, pageSettings, replaceOpions } = options;
     let count = 0;
@@ -33,15 +33,14 @@ export function updateWixTypes(options) {
             return path.join(outputDir);
         }))
             .on('error', function () {
-            console.log(chalk.red.underline.bold('Modification of WIX configs failed!'));
+            console.log("💩" + 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!`)); });
+            .on('end', function () { console.log("🐶" + blue.underline(`Modification of ${yellow(count)} WIX configs succeeded!`)); });
     };
 }
 export function addTypes(options, done) {
-    const { replaceOpions, cwd } = options;
-    console.log('CWD', cwd);
+    const { replaceOpions } = options;
     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/'));
@@ -56,17 +55,17 @@ export function addTypes(options, done) {
         .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(insert.prepend("import { FrontendAPISchema } from '../../../../../../lucy-lib/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!'));
+        console.log("💩" + red.underline.bold(' => Updating WIX failed!'));
         this.emit('end');
         done();
     })
         .on('end', function () {
-        console.log(chalk.blueBright.underline('Add of new Types (store & Global) succeeded!'));
+        console.log("🐶" + blue.underline(' => Updating WIX succeeded!'));
         done();
     });
 }

package/dist/gulp/watchers.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="undertaker" />
+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

@@ -0,0 +1,94 @@
+import gulp from 'gulp';
+import { green } from '../index.js';
+import { buildBackend, buildBackendJSW, buildBackendJSWLib, buildBackendLib } from './backend.js';
+import { buildPublic, buildPublicLib } 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';
+let taskOptions;
+export function watchSCSS() {
+    return gulp.watch([
+        'typescript/styles/**/*.scss',
+        'lucy-lib/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([
+        'lucy-lib/backend/**/*.ts',
+        'lucy-lib/backend/**/*.tsx',
+        '!lucy-lib/backend/**/*.spec.ts',
+        '!lucy-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(['lucy-lib/backend/**/*.jsw.ts'], gulp.parallel(testLib(), checkTsLib(), buildBackendJSWLib(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([
+        'lucy-lib/public/**/*.ts',
+        'lucy-lib/public/**/*.tsx',
+    ], gulp.parallel(testLib(), checkTsLib(), buildPublicLib(taskOptions)));
+}
+export function watchPages() {
+    return gulp.watch('typescript/pages/**/*.ts', gulp.parallel(checkTs(), buildPages(taskOptions)));
+}
+export function watchFiles() {
+    return gulp.watch([
+        'typescript/backend/**/*',
+        'typescript/public/**/*',
+        'typescript/pages/**/*',
+        '!typescript/**/*.ts',
+    ], gulp.parallel(copyFiles(taskOptions)));
+}
+export function watchFilesLib() {
+    return gulp.watch([
+        'lucy-lib/backend/**/*',
+        'lucy-lib/public/**/*',
+        'lucy-lib/pages/**/*',
+        '!lucy-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([
+        'lucy-lib/backend/templates/**/*.tsx',
+        'lucy-lib/backend/templates/data/*.json',
+        '!lucy-lib/backend/templates/render.ts',
+    ], gulp.parallel(previewTemplatesLib(), testLib()));
+}
+export function watchTypes() {
+    return gulp.watch([
+        './.wix/types/**/*.d.ts',
+        '!./.wix/types/wix-code-types'
+    ], gulp.series('fix-wixtypes'));
+}
+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);
+}

package/dist/index.d.ts

@@ -1,2 +1,24 @@
 #!/usr/bin/env node
-export {};
+import settings from './settings.json';
+export type ModuleSettings = {
+    packageRoot: string;
+    targetFolder: string;
+    args: string[];
+    wixConfigPath: string;
+    lucyConfigPath: string;
+    packageJonPath: string;
+    settings: typeof settings;
+};
+export type ProjectSettings = {
+    packages?: Record<string, string>;
+    modules?: Record<string, string>;
+    lucySettings?: Record<string, string>;
+    packageJSON?: Record<string, any>;
+    lucyJSON?: Record<string, any>;
+};
+export declare const orange: import("chalk").ChalkInstance;
+export declare const blue: import("chalk").ChalkInstance;
+export declare const green: import("chalk").ChalkInstance;
+export declare const red: import("chalk").ChalkInstance;
+export declare const yellow: import("chalk").ChalkInstance;
+export declare const magenta: import("chalk").ChalkInstance;

package/dist/index.js

@@ -3,86 +3,86 @@ import { dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { existsSync } 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';
+import { sync } from './sync.js';
+export const orange = chalk.hex('#FFA500');
+export const blue = chalk.blueBright;
+export const green = chalk.greenBright;
+export const red = chalk.redBright;
+export const yellow = chalk.yellow;
+export const magenta = chalk.magentaBright;
 // 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);
 /**
- *
+ * Main function
+ * @returns {Promise<void>}
  */
 async function main() {
     const moduleSettings = {
         packageRoot: dirname(__dirname),
         targetFolder: process.cwd(),
         args: process.argv.slice(2),
+        settings,
         wixConfigPath: join(process.cwd(), 'wix.config.json'),
-        lucyConfigPath: join(process.cwd(), 'lucy.json')
+        lucyConfigPath: join(process.cwd(), 'lucy.json'),
+        packageJonPath: join(process.cwd(), 'package.json'),
     };
-    let projectSettings;
+    let projectSettings = {};
+    if (moduleSettings.args.includes('version') || moduleSettings.args.includes('-v')) {
+        console.log("🐾" + blue.bold(' => 1.0.0'));
+        return;
+    }
+    if (moduleSettings.args.includes('help') || moduleSettings.args.includes('-h')) {
+        console.log("🦮" + green.underline.bold(' => Lucy CLI Help'));
+        return;
+    }
     if (!existsSync(moduleSettings.wixConfigPath)) {
-        console.log(chalk.red.underline.bold(`This is not a WIX project ${moduleSettings.targetFolder}`));
+        console.log((`💩 ${red.underline.bold("=> This is not a WIX project =>")} ${orange(moduleSettings.targetFolder)}`));
         return;
     }
-    const packageJSONraw = await fs.readFile(join(moduleSettings.targetFolder, 'package.json'), 'utf8');
-    const packageJSON = JSON.parse(packageJSONraw);
+    if (existsSync(moduleSettings.packageJonPath)) {
+        const packageJSONraw = await fs.readFile(join(moduleSettings.packageJonPath), 'utf8');
+        try {
+            projectSettings.packageJSON = JSON.parse(packageJSONraw);
+        }
+        catch (parseError) {
+            console.log((`💩 ${red.underline.bold("=> Error parsing package.json =>")} ${orange(parseError)}`));
+            return;
+        }
+    }
     if (existsSync(moduleSettings.lucyConfigPath)) {
         try {
             const data = await fs.readFile(moduleSettings.lucyConfigPath, 'utf8');
-            projectSettings = JSON.parse(data);
+            projectSettings.lucySettings = JSON.parse(data);
         }
         catch (parseError) {
-            console.error(chalk.red.underline.bold('Error parsing Lucy.json', parseError));
+            console.log((`💩 ${red.underline.bold("=> Error parsing Lucy.json =>")} ${orange(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 (!moduleSettings.args.includes('init')) {
+            return console.log(yellow.underline.bold('🐶 => Project not Intialized! Please initialize using "lucy-cli init"'));
+        }
+        ;
     }
-    if (args.includes('init')) {
-        init(cwd, packageRoot, args);
+    if (moduleSettings.args.includes('init')) {
+        console.log("🐕" + magenta.underline(' => Initializing project'));
+        init(moduleSettings, projectSettings);
         return;
     }
-    if (args.includes('dev')) {
-        dev(cwd, args);
+    if (moduleSettings.args.includes('dev')) {
+        dev(moduleSettings, projectSettings);
         return;
     }
-    if (args.includes('sync')) {
-        console.log('Hello serve');
+    if (moduleSettings.args.includes('sync')) {
+        sync(moduleSettings, projectSettings);
         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/dist/init.d.ts

@@ -1,7 +1,8 @@
+import { ModuleSettings, ProjectSettings } from './index.js';
 /**
  * Init Lucy project
  * @param {string} cwd Current working directory
  * @param {string} packageRoot Package root directory
  * @returns {void}
  */
-export declare function init(cwd: string, packageRoot: string, args: string[]): Promise<void>;
+export declare function init(moduleSettings: ModuleSettings, projectSettings: ProjectSettings): Promise<void>;