lucy-cli 1.2.5 → 2.0.0-alpha.1

package/src copy/init.ts

@@ -0,0 +1,183 @@
+import chalk from 'chalk';
+import { existsSync, mkdirSync, promises as fsPromises } from 'fs';
+import fse from 'fs-extra';
+import { join } from 'path';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import enquirer from 'enquirer';
+import { ModuleSettings, ProjectSettings, blue, green, orange, red } from './index.js';
+import { createTemplateFolder, gitInit, installPackages } from './helpers.js';
+
+const { Select } = enquirer as any;
+/**
+ * Init Lucy project
+ * @param {string} cwd Current working directory
+ * @param {string} packageRoot Package root directory
+ * @returns {void}
+ */
+export async function init(moduleSettings: ModuleSettings, projectSettings: ProjectSettings) {
+	
+	if(projectSettings.packageJSON && projectSettings.packageJSON.wixLucy?.initialized && !moduleSettings.args.includes('-f')) {
+		console.log((`💩 ${red.underline.bold("=> This project is already initialized =>")} ${orange(moduleSettings.targetFolder)}`));
+		return;
+	}
+
+	const templatesPath = join(os.homedir(), '.lucy-cli');
+    if (!existsSync(templatesPath)) {
+        console.log(chalk.yellow(`Templates folder not found at ${orange(templatesPath)}. Creating it with a default template...`));
+		await createTemplateFolder(moduleSettings);
+    }
+
+    const templateChoices = (await fs.readdir(templatesPath, { withFileTypes: true }))
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+
+    if (templateChoices.length === 0) {
+        console.log((`💩 ${red.underline.bold("=> No templates found in =>")} ${orange(templatesPath)}`));
+        return;
+    }
+
+    const prompt = new Select({
+        name: 'template',
+        message: 'Select a project template',
+        choices: templateChoices
+    });
+
+    const selectedTemplate = await prompt.run();
+    const templateDir = join(templatesPath, selectedTemplate);
+    const templateFilesDir = join(templateDir, 'files');
+    const templateSettingsPath = join(templateDir, 'settings.json');
+
+    if (!existsSync(templateSettingsPath)) {
+        console.log((`💩 ${red.underline.bold("=> Template is missing settings.json at =>")} ${orange(templateSettingsPath)}`));
+        return;
+    }
+
+    try {
+        const templateSettingsRaw = await fs.readFile(templateSettingsPath, 'utf8');
+        moduleSettings.settings = JSON.parse(templateSettingsRaw);
+    } catch (e) {
+        console.log((`💩 ${red.underline.bold("=> Error reading or parsing template settings =>")} ${orange(e)}`));
+        return;
+    }
+
+	await copyFolder(templateFilesDir, moduleSettings.targetFolder);
+
+	await editJson(moduleSettings.packageJsonPath, ['type', 'scripts'], ['module', moduleSettings.settings.scripts ]);
+	await stringReplace(join(moduleSettings.targetFolder, 'currents.config.js'), ['__ProjectName__'], [path.basename(moduleSettings.targetFolder)]);
+
+	await installPackages(moduleSettings.settings.wixPackages, moduleSettings.settings.devPackages, moduleSettings.targetFolder, moduleSettings.lockVersion);
+
+	await editJson(join(moduleSettings.targetFolder, 'jsconfig.json'), ['compilerOptions', 'exclude'], [moduleSettings.settings.wixSettings.compilerOptions, moduleSettings.settings.wixSettings.exclude]);
+	await editJson(join(moduleSettings.targetFolder, 'typedoc.json'), ['name'], [path.basename(moduleSettings.targetFolder)]);
+
+	await gitInit(moduleSettings.targetFolder, moduleSettings.settings.modules, moduleSettings.force);
+
+	moduleSettings.settings.initialized = true;
+
+	const eslintrcPath = join(moduleSettings.targetFolder, '.eslintrc.json');
+	if(existsSync(eslintrcPath)) {
+		console.log((`🐕 ${blue.underline.bold("=> Deleting .eslintrc.json")}`));
+		await fs.rm(join(eslintrcPath), { recursive: false }).catch(e => {
+			console.log((`💩 ${red.underline.bold("=> Could not delete .eslintrc.json ")} ${red.bold("=> ", e)}`));
+		});
+	}
+
+	console.log((`🐕 ${blue.underline.bold("=> Writing settings to lucy.json")}`));
+	await fs.writeFile(join(moduleSettings.targetFolder, 'lucy.json'), JSON.stringify(moduleSettings.settings, null, 2));
+
+	console.log(chalk.greenBright.underline('🐶 => Initialization 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.log((`💩 ${red.underline.bold("=> Target folder doesn't exist =>")} ${orange(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.log((`💩 ${red.underline.bold("=> There was an error while copying files =>")} ${orange(err)}`));
+	} finally {
+		console.log("🐕" + blue.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.log((`💩 ${red.underline.bold("=> Error parsing JSON =>")} ${orange(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((`💩 ${red.underline.bold("=> Error editing JSON Data =>")} ${orange(err)}`));
+	} finally {
+		console.log("🐕" + blue.underline(` => Updated file ${orange(filePath)}`));
+	}
+}
+
+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((`💩 ${red.underline.bold("=> During string replace =>")} ${orange(err)}`));
+	} finally {
+		console.log(blue.underline(`🐕 => Updated file ${orange(filePath)}`));
+	}
+}

package/src copy/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
+};

package/src copy/prepare.ts

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import { ModuleSettings, ProjectSettings, blue, green, orange, red, magenta } from './index.js';
+import { gitInit, installPackages } from './helpers.js';
+
+/**
+ * Init Lucy project
+ * @param {string} cwd Current working directory
+ * @param {string} packageRoot Package root directory
+ * @returns {void}
+ */
+export async function prepare(moduleSettings: ModuleSettings, projectSettings: ProjectSettings) {
+	
+	if(!projectSettings.lucySettings?.initialized) {
+		console.log((`💩 ${red.underline.bold("=> This project is not initialized =>")} ${orange(moduleSettings.targetFolder)}`));
+		console.log("🐕" + magenta.underline(' => Use init to initialize'));
+		return;
+	}
+
+	await installPackages(projectSettings.lucySettings.wixPackages, projectSettings.lucySettings.devPackages, moduleSettings.targetFolder, moduleSettings.lockVersion);
+
+	await gitInit(moduleSettings.targetFolder, projectSettings?.lucySettings?.modules, moduleSettings.force);
+
+	console.log(chalk.greenBright.underline('🐶 => Prepare done!'));
+}

package/src copy/settings.json

@@ -0,0 +1,67 @@
+{
+  "modules": {},
+  "wixSettings": {
+    "compilerOptions": {
+      "composite": true,
+      "noEmit": false,
+      "lib": [],
+      "jsx": "react-jsx"
+    },
+    "exclude": ["**/*.js"]
+  },
+  "initialized": false,
+  "wixPackages": {},
+  "devPackages": {
+    "@eslint/js": "^9.30.1",
+    "@styled/typescript-styled-plugin": "^1.0.1",
+    "@total-typescript/ts-reset": "^0.6.1",
+    "@types/node": "^24.0.10",
+    "@types/nodemailer": "^6.4.17",
+    "@types/react": "^19.1.8",
+    "madge": "^8.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.35.1",
+    "@typescript-eslint/parser": "^8.35.1",
+    "@typescript-eslint/utils": "^8.35.1",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
+    "@wix/cli": "^1.1.101",
+    "@wix/eslint-plugin-cli": "^1.0.2",
+    "cypress": "^14.5.1",
+    "cypress-cloud": "^1.13.1",
+    "esbuild": "^0.25.5",
+    "eslint": "^9.30.1",
+    "eslint-plugin-exception-handling": "^1.5.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jsdoc": "^51.3.3",
+    "eslint-plugin-named-import-spacing": "^1.0.3",
+    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "prettier": "^3.6.2",
+    "sass": "^1.89.2",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.20.3",
+    "typedoc": "^0.28.7",
+    "typedoc-github-theme": "^0.3.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.35.1",
+    "typescript-eslint-language-service": "^5.0.5",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.2.4",
+    "vitest-tsconfig-paths": "^3.4.1"
+  },
+  "scripts": {
+    "postinstall": "wix sync-types",
+    "wix:dev": "wix dev",
+    "dev": "lucy-cli dev",
+    "lint": "NODE_OPTIONS=\"--max-old-space-size=32768\" eslint .",
+    "docs": "typedoc --tsconfig typescript/tsconfig.json --skipErrorChecking",
+    "build": "lucy-cli build-prod",
+    "fix-wix": "lucy-cli fix-wix",
+    "tsc": "tsc -p ./typescript/tsconfig.json --noEmit",
+    "test": "vitest --ui --coverage",
+    "coverage": "vitest run --coverage",
+    "cypress": "cypress open",
+    "e2e": "cypress-cloud run --parallel --record",
+    "graph": "madge --image graph.svg src"
+  }
+}

package/src copy/types.d.ts

@@ -0,0 +1,8 @@
+declare module 'gulp-exec';
+declare module 'gulp-clean';
+declare module 'gulp-foreach';
+declare module 'gulp-string-replace';
+declare module 'gulp-wait';
+declare module 'gulp-jest';
+declare module 'gulp-flatmap';
+declare module 'gulp-swc';

package/dist/Gulpfile.d.ts

@@ -1,34 +0,0 @@
-import gulpSass from 'gulp-sass';
-import backendSettings from '../settings/backend-settings.json';
-import masterSettings from '../settings/master-settings.json';
-import pageSettings from '../settings/page-settings.json';
-import publicSettings from '../settings/public-settings.json';
-import { ModuleSettings, ProjectSettings } from './index.js';
-export type TaskOptions = {
-    moduleSettings?: ModuleSettings;
-    projectSettings?: ProjectSettings;
-    enableIncrementalBuild: boolean;
-    outputDir: string;
-    sass: ReturnType<typeof gulpSass>;
-    userHomeDir: string;
-    replaceOptions: typeof replaceOptions;
-    backendSettings: typeof backendSettings;
-    masterSettings: typeof masterSettings;
-    pageSettings: typeof pageSettings;
-    publicSettings: typeof publicSettings;
-    modulesSync: Record<string, string> | undefined;
-    modulesSourcePaths: string[];
-    cwd: string;
-    isWatching?: boolean;
-};
-export interface File {
-    path: string;
-    dirname: string;
-}
-declare const replaceOptions: {
-    logs: {
-        enabled: boolean;
-    };
-};
-export declare function runTask(task: string, moduleSettings: ModuleSettings, projectSettings: ProjectSettings): Promise<void>;
-export {};

package/dist/Gulpfile.js

@@ -1,115 +0,0 @@
-import gulp from 'gulp';
-import gulpSass from 'gulp-sass';
-import shell from 'gulp-shell';
-import * as os from 'os';
-import * as dartSass from 'sass';
-import backendSettings from '../settings/backend-settings.json' with { type: "json" };
-;
-import masterSettings from '../settings/master-settings.json' with { type: "json" };
-;
-import pageSettings from '../settings/page-settings.json' with { type: "json" };
-;
-import publicSettings from '../settings/public-settings.json' with { type: "json" };
-;
-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 } 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 { blue, green, magenta, orange, red } from './index.js';
-import { getModulesSourcePaths, getModulesSync } from './gulp/helpers.js';
-const sass = gulpSass(dartSass);
-const outputDir = './src';
-const userHomeDir = os.homedir();
-const replaceOptions = {
-    logs: {
-        enabled: false
-    }
-};
-const taskOptions = {
-    enableIncrementalBuild: false,
-    outputDir,
-    sass,
-    userHomeDir,
-    pageSettings,
-    publicSettings,
-    backendSettings,
-    masterSettings,
-    replaceOptions,
-    cwd: process.cwd(),
-    modulesSync: getModulesSync(),
-    modulesSourcePaths: getModulesSourcePaths(),
-};
-const watchTaskOptions = { ...taskOptions, isWatching: true };
-gulp.task('check-ts', gulp.parallel(checkTs(taskOptions)));
-gulp.task('scss', gulp.parallel(compileScss(taskOptions)));
-gulp.task('build-backend', gulp.parallel(buildBackend(taskOptions), buildBackendJSW(taskOptions)));
-gulp.task('build-public', gulp.parallel(buildPublic(taskOptions)));
-gulp.task('preview-templates', gulp.parallel(previewTemplates(taskOptions)));
-gulp.task('copy-files', gulp.parallel(copyFiles(taskOptions)));
-gulp.task('test', function () {
-    return shell.task(['yarn test'], { ignoreErrors: true })().then(() => {
-        console.log("🐕" + blue.underline.bold(' => Exited test task!'));
-    }).catch(err => {
-        console.log("💩" + red.underline.bold(' => Error in test task!'));
-    });
-});
-gulp.task('test-ci', function () {
-    return shell.task(['yarn test --run'], { ignoreErrors: true })().then(() => {
-        console.log("🐕" + blue.underline.bold(' => Exited test task!'));
-    }).catch(err => {
-        console.log("💩" + red.underline.bold(' => Error in test task!'));
-    });
-});
-gulp.task('sync-types', shell.task([
-    'yarn postinstall',
-]));
-gulp.task('fix-wixtypes', gulp.parallel(updateWixTypes(taskOptions)));
-gulp.task('add-wix-types', function (done) {
-    return addTypes(taskOptions, done);
-});
-gulp.task('set-production', gulp.parallel(setProdConfig()));
-gulp.task('start-wix', shell.task([
-    'yarn wix:dev',
-]));
-gulp.task('gen-docs', shell.task([
-    'yarn docs',
-]));
-gulp.task('fix-wix', gulp.series(cleanWix(), 'sync-types', 'fix-wixtypes', 'add-wix-types'));
-gulp.task('build', gulp.parallel('build-backend', 'build-public', 'preview-templates', buildPages(taskOptions), compileScss(taskOptions), 'copy-files'));
-gulp.task('build-pipeline', gulp.series(cleanSrc(taskOptions), 'set-production', 'check-ts', 'fix-wixtypes', 'add-wix-types', 'test-ci', 'build'));
-gulp.task('build-prod', gulp.series((done) => checkPages(true, false).then(() => done(), (err) => done(err)), cleanSrc(taskOptions), 'set-production', 'fix-wix', 'check-ts', 'test-ci', 'build-backend', 'build-public', buildPages(taskOptions), 'copy-files', compileScss(taskOptions)));
-gulp.task('start-dev-env', gulp.parallel(watchAll(watchTaskOptions), 'test', 'start-wix', 'check-ts', (done) => checkPages(false, taskOptions.moduleSettings?.force ?? false).then(() => done(), (err) => done(err))));
-gulp.task('dev', gulp.series(cleanSrc(taskOptions), 'fix-wix', 'build', 'start-dev-env'));
-async function gulpTaskRunner(task) {
-    return new Promise(function (resolve, reject) {
-        gulp.series(task, (done) => {
-            resolve(true);
-            done();
-        })(function (err) {
-            if (err) {
-                console.log((`💩 ${red.underline.bold("=> Error starting tasks =>")} ${orange(err)}`));
-                reject(err);
-            }
-        });
-    });
-}
-export async function runTask(task, moduleSettings, projectSettings) {
-    taskOptions.cwd = moduleSettings.targetFolder;
-    taskOptions.moduleSettings = moduleSettings;
-    taskOptions.projectSettings = projectSettings;
-    console.log("🐕" + magenta.underline(' => Starting Task => ' + orange(task)));
-    try {
-        await gulpTaskRunner(task);
-    }
-    catch (err) {
-        console.log((`💩 ${red.underline.bold("=> Error starting tasks =>")} ${orange(err)}`));
-    }
-    console.log("🐶" + green.underline.bold(' => Task completed: ' + task));
-}

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli.js

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-import { helloWorld } from './index.js';
-const args = process.argv.slice(2);
-const cwd = process.cwd();
-/**
- *
- */
-function main() {
-    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')) {
-        helloWorld();
-        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/dist/dev.d.ts

@@ -1,2 +0,0 @@
-import { ModuleSettings, ProjectSettings } from '.';
-export declare function dev(moduleSettings: ModuleSettings, projectSettings: ProjectSettings): Promise<void>;

package/dist/dev.js

@@ -1,14 +0,0 @@
-// https://www.sergevandenoever.nl/run-gulp4-tasks-programatically-from-node/
-import path from 'path';
-import { fileURLToPath } from 'url';
-export async function dev(moduleSettings, projectSettings) {
-    // Get the directory name of the current module
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    // Resolve the path to the Gulpfile
-    const gulpfilePath = path.resolve(__dirname, 'Gulpfile.js');
-    // Dynamically import the Gulpfile
-    const gulpfile = await import(`file://${gulpfilePath}`);
-    // Check if 'dev' task exists
-    gulpfile.runTask('dev', moduleSettings, projectSettings);
-}

package/dist/gulp/backend copy.d.ts

@@ -1,4 +0,0 @@
-/// <reference types="node" />
-import { TaksOptions } from '../Gulpfile';
-export declare function buildPublic(options: TaksOptions): () => NodeJS.ReadWriteStream;
-export declare function buildPublicLib(options: TaksOptions): () => NodeJS.ReadWriteStream;

package/dist/gulp/backend copy.js

@@ -1,50 +0,0 @@
-import chalk from 'chalk';
-import gulp from 'gulp';
-import { createGulpEsbuild } from 'gulp-esbuild';
-import * as path from 'path';
-export function buildPublic(options) {
-    const { outputDir, enableIncrementalBuild } = options;
-    const gulpEsbuild = createGulpEsbuild({
-        incremental: enableIncrementalBuild,
-    });
-    return () => {
-        return gulp.src([
-            'typescript/public/**/*.ts',
-            'typescript/public/**/*.tsx',
-        ])
-            .pipe(gulpEsbuild({
-            bundle: false,
-        }))
-            .pipe(gulp.dest(path.join(outputDir, 'public')))
-            .on('error', function () {
-            console.log(chalk.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!'));
-        });
-    };
-}
-export function buildPublicLib(options) {
-    const { outputDir, enableIncrementalBuild } = options;
-    const gulpEsbuild = createGulpEsbuild({
-        incremental: enableIncrementalBuild,
-    });
-    return () => {
-        return gulp.src([
-            'wix-lucy-lib/src/public/**/*.ts',
-            'wix-lucy-lib/src/public/**/*.tsx'
-        ])
-            .pipe(gulpEsbuild({
-            bundle: false,
-        }))
-            .pipe(gulp.dest(path.join(outputDir, 'public')))
-            .on('error', function () {
-            console.log(chalk.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!'));
-        });
-    };
-}

package/dist/gulp/backend.d.ts

@@ -1,3 +0,0 @@
-import { TaskOptions } from '../Gulpfile';
-export declare function buildBackend(options: TaskOptions): import("undertaker").TaskFunction;
-export declare function buildBackendJSW(options: TaskOptions): import("undertaker").TaskFunction;