lucy-cli 0.0.4

package/.eslintrc.cjs

@@ -0,0 +1,96 @@
+module.exports = {
+	extends: ['eslint:recommended', 'plugin:import/recommended', 'plugin:jsdoc/recommended', 'plugin:@typescript-eslint/recommended'],
+	plugins: ['simple-import-sort', 'eslint-plugin-named-import-spacing', '@typescript-eslint'],
+	parser: '@typescript-eslint/parser',
+	ignorePatterns: ['src/**/*', 'typescript/types/backend/**/*', 'typescript/types/pages/**/*', 'typescript/types/public/**/*', 'typescript/types/node/**/*', '.wix/**/*', 'coverage/**/*', 'docs/**/*'],
+	rules: {
+		quotes: [2, 'single', { 'avoidEscape': true, 'allowTemplateLiterals': true }],
+		curly: ['error', 'multi-line'],
+		'simple-import-sort/imports': 'error',
+		'simple-import-sort/exports': 'error',
+		indent: ['error', 'tab'],
+		'no-tabs': 0,
+		'semi-style': ['error', 'last'],
+		semi: [2, 'always'],
+		'object-curly-spacing': ['error', 'always'],
+		'space-in-parens': ['error', 'never'],
+		'newline-before-return': 'error',
+		'space-before-blocks': ['error', { functions: 'always', keywords: 'never', classes: 'always' }],
+		'comma-spacing': ['error', { before: false, after: true }],
+		'no-multi-spaces': ['error'],
+		'import/newline-after-import': ['error', { count: 1 }],
+		'named-import-spacing/named-import-spacing': 2,
+		'no-unused-vars': 'warn',
+		'import/no-unresolved': [0],
+		'no-forbidden-relative-imports': [0],
+		'@typescript-eslint/triple-slash-reference': 'off',
+		'@typescript-eslint/member-ordering': [
+			'error',
+			{ classes: ['constructor', 'private-instance-field', 'protected-instance-field', 'public-instance-field', 'public-instance-method', 'private-instance-method'] }
+		],
+		'@typescript-eslint/naming-convention': [
+			'error',
+			{
+				selector: ['variable', 'function'],
+				format: ['camelCase'],
+				leadingUnderscore: 'allow'
+			},
+			{
+				selector: ['objectLiteralProperty'],
+				format: null,
+				leadingUnderscore: 'allow'
+			},
+			{
+				selector: 'memberLike',
+				modifiers: ['private'],
+				format: ['camelCase'],
+				leadingUnderscore: 'require'
+			},
+			{
+				selector: 'memberLike',
+				modifiers: ['protected'],
+				format: ['camelCase'],
+				leadingUnderscore: 'require'
+			},
+			{
+				selector: 'memberLike',
+				modifiers: ['public'],
+				format: ['camelCase'],
+				leadingUnderscore: 'forbid'
+			},
+			{
+				selector: ['parameterProperty', 'parameter'],
+				format: ['camelCase'],
+				leadingUnderscore: 'forbid'
+			},
+			{
+				selector: 'default',
+				format: ['UPPER_CASE'],
+				leadingUnderscore: 'forbid',
+				trailingUnderscore: 'forbid',
+				custom: {
+					regex: '^[A-Z_]+$',
+					match: true
+				}
+			},
+			{
+				selector: 'typeLike',
+				format: ['PascalCase']
+			},
+			// Custom rule added
+			{
+				selector: 'function',
+				format: ['UPPER_CASE']
+			}
+		],
+	},
+	root: true,
+	env: {
+		es6: true,
+		browser: true,
+		node: true
+	},
+	globals: {
+		$w: 'readonly'
+	}
+};

package/.eslintrc.json

@@ -0,0 +1,3 @@
+{
+  "extends": ["plugin:@wix/cli/recommended"]
+}

package/.nvmrc

@@ -0,0 +1 @@
+20

package/.yarnrc.yml

@@ -0,0 +1,5 @@
+nodeLinker: node-modules
+
+npmRegistryServer: "https://registry.npmjs.org/"
+
+yarnPath: .yarn/releases/yarn-3.7.0.cjs

package/README.md

@@ -0,0 +1 @@
+# wix-lucy

package/dist/Gulpfile.d.ts

@@ -0,0 +1,28 @@
+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';
+export type TaskOptions = {
+    enableIncrementalBuild: boolean;
+    outputDir: string;
+    sass: ReturnType<typeof gulpSass>;
+    userHomeDir: string;
+    replaceOpions: typeof replaceOpions;
+    backendSettings: typeof backendSettings;
+    masterSettings: typeof masterSettings;
+    pageSettings: typeof pageSettings;
+    publicSettings: typeof publicSettings;
+    cwd: string;
+};
+export interface File {
+    path: string;
+    dirname: string;
+}
+declare const replaceOpions: {
+    logs: {
+        enabled: boolean;
+    };
+};
+export declare function runTask(task: string, cwd: string): Promise<void>;
+export {};

package/dist/Gulpfile.js

@@ -0,0 +1,179 @@
+import chalk from 'chalk';
+import gulp from 'gulp';
+import clean from 'gulp-clean';
+import gulpSass from 'gulp-sass';
+import shell from 'gulp-shell';
+import replace from 'gulp-string-replace';
+import * as os from 'os';
+import * as path from 'path';
+import * as dartSass from 'sass';
+import backendSettings from '../settings/backend-settings.json' assert { type: 'json' };
+import masterSettings from '../settings/master-settings.json' assert { type: 'json' };
+import pageSettings from '../settings/page-settings.json' assert { type: 'json' };
+import publicSettings from '../settings/public-settings.json' assert { type: 'json' };
+import { buildPublic, buildPublicLib } from './gulp/public.js';
+import { buildBackend, buildBackendJSW } from './gulp/backend.js';
+import { checkPages, checkTs, checkTsLib } 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 { cleanWix } from './gulp/clean.js';
+import { addTypes, updateWixTypes } from './gulp/types.js';
+const sass = gulpSass(dartSass);
+let enableIncrementalBuild = false;
+const outputDir = './src';
+const userHomeDir = os.homedir();
+const replaceOpions = {
+    logs: {
+        enabled: false
+    }
+};
+const taskOptions = {
+    enableIncrementalBuild,
+    outputDir,
+    sass,
+    userHomeDir,
+    pageSettings,
+    publicSettings,
+    backendSettings,
+    masterSettings,
+    replaceOpions,
+    cwd: process.cwd(),
+};
+gulp.task('check-pages', gulp.parallel(checkPages));
+gulp.task('check-ts', gulp.parallel(checkTs(), checkTsLib()));
+gulp.task('scss', gulp.parallel(compileScss(taskOptions)));
+gulp.task('build-jsw', gulp.parallel(buildBackendJSW(taskOptions)));
+gulp.task('build-backend', gulp.parallel(buildBackend(taskOptions)));
+gulp.task('build-public', gulp.parallel(buildPublic(taskOptions), buildPublicLib(taskOptions)));
+gulp.task('build-pages', gulp.parallel(buildPages(taskOptions)));
+gulp.task('preview-templates', gulp.parallel(previewTemplates()));
+gulp.task('copy-files', gulp.parallel(copyFiles(taskOptions)));
+gulp.task('clean-wix', gulp.parallel(cleanWix()));
+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('clean-src', async () => {
+    return gulp.src([`${outputDir}/pages`, `${outputDir}/public`, `${outputDir}/backend`], { read: false, allowEmpty: true })
+        .pipe(clean({ force: true }))
+        .on('error', function () {
+        console.log(chalk.red.underline.bold('Cleaning of output files failed!'));
+        this.emit('end');
+    })
+        .on('end', function () { console.log(chalk.blueBright.underline('Cleaning of output files succeeded!')); });
+});
+gulp.task('set-production', function () {
+    const droneTag = process.env.DRONE_TAG || 'development';
+    const regexGit = /gitTag:\s*(.*),/g;
+    const regexDev = /devMode:\s*(.*),/g;
+    return gulp
+        .src(['./typescript/public/constants/config.ts'])
+        .pipe(replace(regexGit, `gitTag: '${droneTag}',`))
+        .pipe(replace(regexDev, `devMode: false,`))
+        .pipe(gulp.dest((file) => {
+        const filePath = file.dirname;
+        const outputDir = path.dirname(filePath);
+        return path.join(`${outputDir}/constants`);
+    }))
+        .on('error', function () {
+        console.log(chalk.red.underline.bold('Setting the git tag failed!'));
+        this.emit('end');
+    })
+        .on('end', function () { console.log(chalk.blueBright.underline('Setting the git tag succeeded!')); });
+});
+gulp.task('start-wix', shell.task([
+    'yarn wix:dev',
+]));
+gulp.task('test-watch', shell.task([
+    'sleep 10; yarn test --watch',
+]));
+gulp.task('test', shell.task([
+    'sleep 2; yarn test',
+]));
+gulp.task('gen-docs', shell.task([
+    'yarn docs',
+]));
+gulp.task('watch-scss', () => {
+    gulp.watch(['typescript/public/scss/**/*.scss'], gulp.series('scss'));
+});
+gulp.task('watch-jsw', () => {
+    enableIncrementalBuild = true;
+    gulp.watch(['typescript/backend/**/frontend.*.ts', 'wix-lucy-lib/backend/**/frontend.*.ts'], gulp.series('check-ts', 'build-jsw', 'test'));
+});
+gulp.task('watch-backend', () => {
+    enableIncrementalBuild = true;
+    gulp.watch([
+        'typescript/backend/**/*.ts',
+        'typescript/backend/**/*.tsx',
+        '!typescript/backend/**/*.spec.ts',
+    ], gulp.series('check-ts', 'build-backend', 'test'));
+});
+gulp.task('watch-public', () => {
+    enableIncrementalBuild = true;
+    gulp.watch([
+        'typescript/public/**/*.ts',
+        'typescript/public/**/*.tsx',
+        'wix-lucy-lib/src/public/**/*.ts',
+        'wix-lucy-lib/src/public/**/*.tsx'
+    ], gulp.series('check-ts', 'build-public', 'test'));
+});
+gulp.task('watch-templates', () => {
+    gulp.watch([
+        'typescript/backend/templates/**/*.tsx',
+        'typescript/backend/templates/data/*.json',
+        '!typescript/backend/templates/render.ts',
+    ], gulp.series('preview-templates'));
+});
+gulp.task('watch-pages', () => {
+    enableIncrementalBuild = true;
+    gulp.watch('typescript/pages/**/*.ts', gulp.series('check-ts', 'build-pages', 'test'));
+});
+gulp.task('watch-files', () => {
+    enableIncrementalBuild = true;
+    gulp.watch([
+        'typescript/backend/**/*',
+        'typescript/public/**/*',
+        'typescript/pages/**/*',
+        '!typescript/**/*.ts',
+    ], gulp.series('copy-files'));
+});
+gulp.task('watch-types', () => {
+    enableIncrementalBuild = true;
+    gulp.watch(['./.wix/types/**/*.d.ts', '!./.wix/types/wix-code-types'], gulp.series('fix-wixtypes'));
+});
+gulp.task('fix-wix', gulp.series('clean-wix', 'sync-types', 'fix-wixtypes', 'add-wix-types'));
+gulp.task('clean', gulp.series('clean-src'));
+gulp.task('watch', gulp.parallel('watch-types', 'watch-jsw', 'watch-backend', 'watch-public', 'watch-pages', 'watch-files', 'watch-scss', 'watch-templates'));
+gulp.task('build-prod', gulp.series('clean', 'set-production', 'fix-wix', 'check-pages', 'build-jsw', 'build-backend', 'build-public', 'build-pages', 'copy-files', 'scss', 'gen-docs'));
+gulp.task('build', gulp.series('clean', 'fix-wix', 'check-ts', 'build-jsw', 'build-backend', 'build-public', 'build-pages', 'scss', 'copy-files'));
+gulp.task('fix-for-test', gulp.series('fix-wixtypes', 'add-wix-types'));
+gulp.task('build-pipeline', gulp.series('clean', 'set-production', 'build-jsw', 'build-backend', 'build-public', 'build-pages', 'copy-files', 'scss', 'gen-docs'));
+gulp.task('start-dev-env', gulp.parallel('watch', 'check-pages'));
+gulp.task('dev', gulp.series('build', 'start-dev-env', 'test-watch'));
+gulp.task('default', gulp.series('dev'));
+async function gulpTaskRunner(task) {
+    return new Promise(function (resolve, reject) {
+        gulp.series(task, (done) => {
+            resolve(true);
+            done();
+        })(function (err) {
+            console.log('gulpTaskRunner', err);
+            if (err) {
+                reject(err);
+            }
+        });
+    });
+}
+export async function runTask(task, cwd) {
+    console.log('runTask', { task, cwd });
+    taskOptions.cwd = cwd;
+    console.log('runTask', { task, cwd });
+    console.log('start');
+    await gulpTaskRunner(task);
+    console.log('end');
+}

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,44 @@
+#!/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

@@ -0,0 +1 @@
+export declare function dev(cwd: string, arg: string[]): Promise<void>;

package/dist/dev.js

@@ -0,0 +1,14 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+export async function dev(cwd, arg) {
+    console.log('dev', { cwd, arg });
+    // 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', cwd);
+}

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

@@ -0,0 +1,4 @@
+/// <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

@@ -0,0 +1,50 @@
+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

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

package/dist/gulp/backend.js

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import gulp from 'gulp';
+import { createGulpEsbuild } from 'gulp-esbuild';
+import rename from 'gulp-rename';
+import * as path from 'path';
+export function buildBackend(options) {
+    const { outputDir, enableIncrementalBuild } = options;
+    const gulpEsbuild = createGulpEsbuild({
+        incremental: enableIncrementalBuild,
+    });
+    return () => {
+        return gulp.src([
+            'typescript/backend/**/*.ts',
+            'typescript/backend/**/*.tsx',
+            '!typescript/backend/**/frontend.*.ts',
+            '!typescript/backend/**/*.spec.ts',
+        ])
+            .pipe(gulpEsbuild({
+            bundle: false,
+        }))
+            .pipe(gulp.dest(path.join(outputDir, 'backend')))
+            .on('error', function () {
+            console.log(chalk.red.underline.bold('Build of Backend TS files failed!'));
+            this.emit('end');
+        })
+            .on('end', function () {
+            console.log(chalk.blueBright.underline('Build of Backend TS files succeeded!'));
+        });
+    };
+}
+export function buildBackendJSW(options) {
+    const { outputDir, enableIncrementalBuild } = options;
+    const gulpEsbuild = createGulpEsbuild({
+        incremental: enableIncrementalBuild,
+    });
+    return () => {
+        return gulp.src(['typescript/backend/**/*.jsw.ts', 'wix-lucy-lib/backend/**/*.jsw.ts'])
+            .pipe(gulpEsbuild({
+            bundle: false,
+        }))
+            .pipe(rename({ extname: '.jsw' }))
+            .pipe(gulp.dest(path.join(outputDir, 'backend')))
+            .on('error', function () {
+            console.log(chalk.red.underline.bold('Build of JSW files failed!'));
+            this.emit('end');
+        })
+            .on('end', function () { console.log(chalk.blueBright.underline('Build of JSW files succeeded!')); });
+    };
+}

package/dist/gulp/checks.d.ts

@@ -0,0 +1,3 @@
+export declare function checkPages(): Promise<void>;
+export declare function checkTs(): () => import("gulp-typescript/release/project").ICompileStream;
+export declare function checkTsLib(): () => import("gulp-typescript/release/project").ICompileStream;

package/dist/gulp/checks.js

@@ -0,0 +1,119 @@
+import chalk from 'chalk';
+import * as fs from 'fs';
+import glob from 'glob';
+import * as path from 'path';
+import gulp from 'gulp';
+import ts from 'gulp-typescript';
+/**
+ *  Extracts a match from a file
+ * @param {string} filePath File path
+ * @param {string} pattern Pattern to match
+ */
+function extractMatchFromFile(filePath, pattern) {
+    return new Promise((resolve, reject) => {
+        fs.readFile(filePath, 'utf8', (err, data) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            const regex = new RegExp(pattern);
+            const match = regex.exec(data);
+            const capturedGroup = match ? match.groups?.page : null;
+            resolve(capturedGroup);
+        });
+    });
+}
+/**
+ * Reads files in a folder
+ * @param {string} folderPath Folder path
+ * @param {string} pattern Pattern to match
+ * @param {string} globPattern Glob pattern
+ */
+function readFilesInFolder(folderPath, pattern, globPattern) {
+    return new Promise((resolve, reject) => {
+        glob(path.join(folderPath, globPattern), (err, files) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            const filenameList = [];
+            /**
+             * Traverse files
+             * @param {number} index Index
+             */
+            function traverseFiles(index) {
+                if (index === files.length) {
+                    resolve(filenameList);
+                    return;
+                }
+                const file = files[index];
+                if (pattern) {
+                    if (!file)
+                        return;
+                    extractMatchFromFile(file, pattern)
+                        .then((capturedGroup) => {
+                        if (capturedGroup) {
+                            filenameList.push(capturedGroup);
+                        }
+                        traverseFiles(index + 1);
+                    })
+                        .catch(reject);
+                }
+                if (!pattern) {
+                    if (!file)
+                        return;
+                    filenameList.push(path.basename(file));
+                    traverseFiles(index + 1);
+                }
+            }
+            traverseFiles(0);
+        });
+    });
+}
+export async function checkPages() {
+    console.log(chalk.blueBright.underline.bold('Checking pages...'));
+    const sourcePages = await readFilesInFolder('./.wix/types/', '\\/pages\\/(?<page>.*\\.ts)', '**/*.json');
+    const tsPages = await readFilesInFolder('./typescript/pages', null, '**/*.ts');
+    const sourcePagesSet = new Set(sourcePages);
+    const tsPagesSet = new Set(tsPages);
+    const missingInTs = Array.from(sourcePagesSet).filter((item) => !tsPages.includes(item));
+    const obsoleteInTs = Array.from(tsPagesSet).filter((item) => !sourcePages.includes(item));
+    if (missingInTs.length > 0) {
+        console.log(chalk.yellow.underline.bold('Missing in ts folder: '), '\n', missingInTs);
+        throw new Error('Missing in ts folder');
+    }
+    if (obsoleteInTs.length > 0) {
+        console.log(chalk.yellow.underline.bold('Obsolete in ts folder'), '\n', obsoleteInTs);
+        throw new Error('Obsolete in ts folder');
+    }
+    if (missingInTs.length === 0 || obsoleteInTs.length === 0)
+        console.log(chalk.blueBright.underline.bold('Files are insync!'));
+}
+export function checkTs() {
+    const tsProject = ts.createProject('./wix-lucy-lib/tsconfig.json', { noEmit: true });
+    return () => {
+        return gulp.src(['wix-lucy-lib/typescript/**/*.ts', '!wix-lucy-lib/typescript/types/**/*.ts'], { cwd: 'typescript' })
+            .pipe(tsProject(ts.reporter.fullReporter()))
+            .on('error', function () {
+            console.log(chalk.red.underline.bold('Typescript (LIB) error!'));
+            this.emit('end');
+        })
+            .on('end', function () {
+            console.log(chalk.blueBright.underline('Typescript check succeeded!'));
+        });
+    };
+}
+export function checkTsLib() {
+    const tsProject = ts.createProject('./wix-lucy-lib/tsconfig.json', { noEmit: true });
+    return () => {
+        return gulp.src(['wix-lucy-lib/typescript/**/*.ts', '!wix-lucy-lib/typescript/types/**/*.ts'], { cwd: 'typescript' })
+            .pipe(tsProject(ts.reporter.fullReporter()))
+            .on('error', function () {
+            console.log(chalk.red.underline.bold('Typescript (LIB) error!'));
+            this.emit('end');
+        })
+            .on('end', function () {
+            console.log(chalk.blueBright.underline('Typescript check (LIB) succeeded!'));
+        });
+    };
+}

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

@@ -0,0 +1,2 @@
+import { TaksOptions } from '../Gulpfile';
+export declare function cleanWix(options: TaksOptions): () => any;

package/dist/gulp/clean copy.js

@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+import gulp from 'gulp';
+import { createGulpEsbuild } from 'gulp-esbuild';
+import clean from 'gulp-clean';
+export function cleanWix(options) {
+    const { outputDir, enableIncrementalBuild } = options;
+    const gulpEsbuild = createGulpEsbuild({
+        incremental: enableIncrementalBuild,
+    });
+    return () => {
+        return gulp.src('./.wix', { read: false, allowEmpty: true })
+            .pipe(clean({ force: true }))
+            .on('error', function () {
+            console.log(chalk.red.underline.bold('Cleaning of .wix failed!'));
+            this.emit('end');
+        })
+            .on('end', function () { console.log(chalk.blueBright.underline('Cleaning of .wix succeeded!')); });
+    };
+}

package/dist/gulp/clean.d.ts

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

package/dist/gulp/clean.js

@@ -0,0 +1,14 @@
+import chalk from 'chalk';
+import gulp from 'gulp';
+import clean from 'gulp-clean';
+export function cleanWix() {
+    return () => {
+        return gulp.src('./.wix', { read: false, allowEmpty: true })
+            .pipe(clean({ force: true }))
+            .on('error', function () {
+            console.log(chalk.red.underline.bold('Cleaning of .wix failed!'));
+            this.emit('end');
+        })
+            .on('end', function () { console.log(chalk.blueBright.underline('Cleaning of .wix succeeded!')); });
+    };
+}