lucy-cli 0.0.4

package/dist/gulp/copy.d.ts

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

package/dist/gulp/copy.js

@@ -0,0 +1,22 @@
+import gulp from 'gulp';
+import chalk from 'chalk';
+export function copyFiles(options) {
+    const { outputDir } = options;
+    return () => {
+        return gulp.src([
+            'typescript/**/*',
+            '!typescript/*tsconfig.json',
+            '!typescript/**/*.ts',
+            '!typescript/**/*.tsx',
+            '!typescript/types/**/**',
+            '!typescript/__mocks__/**/**',
+            '!typescript/public/scss/**',
+        ])
+            .pipe(gulp.dest(outputDir))
+            .on('error', function () {
+            console.log(chalk.red.underline.bold('Copy of files failed!'));
+            this.emit('end');
+        })
+            .on('end', function () { console.log(chalk.blueBright.underline('Copy of files succeeded!')); });
+    };
+}

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

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

package/dist/gulp/pages copy.js

@@ -0,0 +1,22 @@
+import gulp from 'gulp';
+import chalk from 'chalk';
+import { createGulpEsbuild } from 'gulp-esbuild';
+import * as path from 'path';
+export function buildPages(options) {
+    const { outputDir, enableIncrementalBuild } = options;
+    const gulpEsbuild = createGulpEsbuild({
+        incremental: enableIncrementalBuild, // enables the esbuild's incremental build
+    });
+    return () => {
+        return gulp.src('typescript/pages/*.ts')
+            .pipe(gulpEsbuild({
+            bundle: false,
+        }))
+            .pipe(gulp.dest(path.join(outputDir, 'pages')))
+            .on('error', function () {
+            console.log(chalk.red.underline.bold('Build of Pages TS files failed!'));
+            this.emit('end');
+        })
+            .on('end', function () { console.log(chalk.blueBright.underline('Build of Pages TS files succeeded!')); });
+    };
+}

package/dist/gulp/pages.d.ts

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

package/dist/gulp/pages.js

@@ -0,0 +1,22 @@
+import gulp from 'gulp';
+import chalk from 'chalk';
+import { createGulpEsbuild } from 'gulp-esbuild';
+import * as path from 'path';
+export function buildPages(options) {
+    const { outputDir, enableIncrementalBuild } = options;
+    const gulpEsbuild = createGulpEsbuild({
+        incremental: enableIncrementalBuild, // enables the esbuild's incremental build
+    });
+    return () => {
+        return gulp.src('typescript/pages/*.ts')
+            .pipe(gulpEsbuild({
+            bundle: false,
+        }))
+            .pipe(gulp.dest(path.join(outputDir, 'pages')))
+            .on('error', function () {
+            console.log(chalk.red.underline.bold('Build of Pages TS files failed!'));
+            this.emit('end');
+        })
+            .on('end', function () { console.log(chalk.blueBright.underline('Build of Pages TS files succeeded!')); });
+    };
+}

package/dist/gulp/public.d.ts

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

package/dist/gulp/public.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/styles.d.ts

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

package/dist/gulp/styles.js

@@ -0,0 +1,17 @@
+import gulp from 'gulp';
+import chalk from 'chalk';
+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`))
+            .on('error', function () {
+            console.log(chalk.red.underline.bold('Compiling of scss files failed!'));
+            this.emit('end');
+        })
+            .on('end', function () {
+            console.log(chalk.blueBright.underline('Compiling of scss files succeeded!'));
+        });
+    };
+}

package/dist/gulp/templates.d.ts

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

package/dist/gulp/templates.js

@@ -0,0 +1,21 @@
+import gulp from 'gulp';
+import chalk from 'chalk';
+import exec from 'gulp-exec';
+export function previewTemplates() {
+    const options = {
+        continueOnError: true,
+    };
+    return () => {
+        return gulp.src([
+            'typescript/backend/templates/**/*.tsx',
+            'typescript/backend/templates/data/*.json',
+            '!typescript/backend/templates/render.ts',
+        ])
+            .pipe(exec((file) => `npx ts-node-esm -T ${file.path}`, options))
+            .on('error', function () {
+            console.log(chalk.red.underline.bold('Render of Template failed!'));
+            this.emit('end');
+        })
+            .on('end', function () { console.log(chalk.blueBright.underline('Render of Template succeeded!')); });
+    };
+}

package/dist/gulp/types.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import gulp from 'gulp';
+import { TaskOptions } from '../Gulpfile';
+export declare function updateWixTypes(options: TaskOptions): () => any;
+export declare function addTypes(options: TaskOptions, done: gulp.TaskFunctionCallback): NodeJS.ReadWriteStream;

package/dist/gulp/types.js

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import gulp from 'gulp';
+import * as path from 'path';
+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) {
+    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, 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) => {
+            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, done) {
+    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/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+import chalk from 'chalk';
+import { join } from 'path';
+import fs from 'fs/promises';
+import { init } from './init.js';
+import { dev } from './dev.js';
+// 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 = {
+        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;
+    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/dist/init.d.ts

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

package/dist/init.js

@@ -0,0 +1,176 @@
+import chalk from 'chalk';
+import { existsSync, mkdirSync, promises as fsPromises } from 'fs';
+import fse from 'fs-extra';
+import { join } from 'path';
+import { simpleGit } 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';
+/**
+ * Init Lucy project
+ * @param {string} cwd Current working directory
+ * @param {string} packageRoot Package root directory
+ * @returns {void}
+ */
+export async function init(cwd, packageRoot, args) {
+    const sourceFolder = join(packageRoot, 'files');
+    const targetFolder = cwd;
+    let projectSettings;
+    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, target) {
+    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, keys, values) {
+    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, keys, values) {
+    try {
+        let modifiedContent = '';
+        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, cwd) {
+    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, modules) {
+    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/dist/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"
+    }
+}