diff --git a/packages/fs/package-lock.json b/packages/fs/package-lock.json
index 075b5291..a94de810 100644
--- a/packages/fs/package-lock.json
+++ b/packages/fs/package-lock.json
@@ -178,6 +178,7 @@
"integrity": "sha512-ywP2X0DYtX3y08eFVx5fNIw7/uIv8hYUKgXoK8oayJlLnKcRfEYCxWMVE1XagUdVtCJlZT1AU4LXEABW+L1Peg==",
"dev": true,
"license": "MIT",
+ "peer": true,
"dependencies": {
"undici-types": "~6.20.0"
}
@@ -934,6 +935,7 @@
"integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==",
"dev": true,
"license": "Apache-2.0",
+ "peer": true,
"bin": {
"tsc": "bin/tsc",
"tsserver": "bin/tsserver"
diff --git a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/.editorconfig b/packages/kbot/gui/app/examples/api/src-tauri/gen/android/.editorconfig
deleted file mode 100644
index ebe51d3b..00000000
--- a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/.editorconfig
+++ /dev/null
@@ -1,12 +0,0 @@
-# EditorConfig is awesome: https://EditorConfig.org
-
-# top-most EditorConfig file
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = false
-insert_final_newline = false
\ No newline at end of file
diff --git a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/.gitignore b/packages/kbot/gui/app/examples/api/src-tauri/gen/android/.gitignore
deleted file mode 100644
index b2482031..00000000
--- a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/.gitignore
+++ /dev/null
@@ -1,19 +0,0 @@
-*.iml
-.gradle
-/local.properties
-/.idea/caches
-/.idea/libraries
-/.idea/modules.xml
-/.idea/workspace.xml
-/.idea/navEditor.xml
-/.idea/assetWizardSettings.xml
-.DS_Store
-build
-/captures
-.externalNativeBuild
-.cxx
-local.properties
-key.properties
-
-/.tauri
-/tauri.settings.gradle
\ No newline at end of file
diff --git a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/.gitignore b/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/.gitignore
deleted file mode 100644
index 4008dd74..00000000
--- a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/.gitignore
+++ /dev/null
@@ -1,6 +0,0 @@
-/src/main/java/com/tauri/api/generated
-/src/main/jniLibs/**/*.so
-/src/main/assets/tauri.conf.json
-/tauri.build.gradle.kts
-/proguard-tauri.pro
-/tauri.properties
\ No newline at end of file
diff --git a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/build.gradle.kts b/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/build.gradle.kts
deleted file mode 100644
index f7047ca0..00000000
--- a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/build.gradle.kts
+++ /dev/null
@@ -1,69 +0,0 @@
-import java.util.Properties
-
-plugins {
- id("com.android.application")
- id("org.jetbrains.kotlin.android")
- id("rust")
-}
-
-val tauriProperties = Properties().apply {
- val propFile = file("tauri.properties")
- if (propFile.exists()) {
- propFile.inputStream().use { load(it) }
- }
-}
-
-android {
- compileSdk = 34
- namespace = "com.tauri.api"
- defaultConfig {
- manifestPlaceholders["usesCleartextTraffic"] = "false"
- applicationId = "com.tauri.api"
- minSdk = 24
- targetSdk = 34
- versionCode = tauriProperties.getProperty("tauri.android.versionCode", "1").toInt()
- versionName = tauriProperties.getProperty("tauri.android.versionName", "1.0")
- }
- buildTypes {
- getByName("debug") {
- manifestPlaceholders["usesCleartextTraffic"] = "true"
- isDebuggable = true
- isJniDebuggable = true
- isMinifyEnabled = false
- packaging { jniLibs.keepDebugSymbols.add("*/arm64-v8a/*.so")
- jniLibs.keepDebugSymbols.add("*/armeabi-v7a/*.so")
- jniLibs.keepDebugSymbols.add("*/x86/*.so")
- jniLibs.keepDebugSymbols.add("*/x86_64/*.so")
- }
- }
- getByName("release") {
- isMinifyEnabled = true
- proguardFiles(
- *fileTree(".") { include("**/*.pro") }
- .plus(getDefaultProguardFile("proguard-android-optimize.txt"))
- .toList().toTypedArray()
- )
- }
- }
- kotlinOptions {
- jvmTarget = "1.8"
- }
- buildFeatures {
- buildConfig = true
- }
-}
-
-rust {
- rootDirRel = "../../../"
-}
-
-dependencies {
- implementation("androidx.webkit:webkit:1.6.1")
- implementation("androidx.appcompat:appcompat:1.6.1")
- implementation("com.google.android.material:material:1.8.0")
- testImplementation("junit:junit:4.13.2")
- androidTestImplementation("androidx.test.ext:junit:1.1.4")
- androidTestImplementation("androidx.test.espresso:espresso-core:3.5.0")
-}
-
-apply(from = "tauri.build.gradle.kts")
\ No newline at end of file
diff --git a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/proguard-rules.pro b/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/proguard-rules.pro
deleted file mode 100644
index 481bb434..00000000
--- a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/proguard-rules.pro
+++ /dev/null
@@ -1,21 +0,0 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-# http://developer.android.com/guide/developing/tools/proguard.html
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-# public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile
\ No newline at end of file
diff --git a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/src/main/AndroidManifest.xml b/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/src/main/AndroidManifest.xml
deleted file mode 100644
index 8ebe7c4b..00000000
--- a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/src/main/AndroidManifest.xml
+++ /dev/null
@@ -1,57 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/src/main/java/com/tauri/api/MainActivity.kt b/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/src/main/java/com/tauri/api/MainActivity.kt
deleted file mode 100644
index 0a05f42b..00000000
--- a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/src/main/java/com/tauri/api/MainActivity.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package com.tauri.api
-
-class MainActivity : TauriActivity()
\ No newline at end of file
diff --git a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml b/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml
deleted file mode 100644
index 2b068d11..00000000
--- a/packages/kbot/gui/app/examples/api/src-tauri/gen/android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-
-
- ![]()
`
+ const name = imageName(imgSrc);
+ const _path = decodeURIComponent(parsed.path).replace('//', '');
+ const imageSrcPath = `${root}/${_path}`;
+ if (!exists(imageSrcPath)) {
+ console.log('image doesnt exists : ' + imageSrcPath + ' \n\t' + imgSrc);
+ return;
+ }
+ const imageSrcPathParts = path.parse(imageSrcPath);
+
+ const imgSrc80 = imgSrc.replace(name, '80/' + name);
+ const imgSrc60 = imgSrc.replace(name, '60/' + name);
+ const imgSrc40 = imgSrc.replace(name, '40/' + name);
+ const imgSrc20 = imgSrc.replace(name, '20/' + name);
+
+ const _set = (res) => {
+ return path.resolve(imageSrcPathParts.dir + '/' + res + '/' + name);
+ }
+
+ if (!exists(_set(80))) {
+ console.error('doesnt exists ', _set(80), imgSrc);
+ continue;
+ }
+
+ if (!exists(_set(60))) {
+ console.error('doesnt exists ', _set(60), imgSrc);
+ continue;
+ }
+ if (!exists(_set(40))) {
+ console.error('doesnt exists ', _set(40), imgSrc);
+ continue;
+ }
+ if (!exists(_set(20))) {
+ console.error('doesnt exists ', _set(20), imgSrc);
+ continue;
+ }
+
+ const img80 = await sharp(_set(80));
+ const md80 = await img80.metadata();
+ srcSet.push(`${imgSrc80.replace(/\s/g,'%20')} ${md80.width}w`);
+
+ // Repeat
+ const img60 = await sharp(_set(60));
+ const md60 = await img60.metadata();
+ srcSet.push(`${imgSrc60.replace(/\s/g,'%20')} ${md60.width}w`);
+
+ // Repeat
+ const img40 = await sharp(_set(40));
+ const md40 = await img40.metadata();
+ srcSet.push(`${imgSrc40.replace(/\s/g,'%20')} ${md40.width}w`);
+
+ // Repeat
+ const img20 = await sharp(_set(20));
+ const md20 = await img20.metadata();
+ srcSet.push(`${imgSrc20.replace(/\s/g,'%20')} ${md20.width}w`);
+
+ // Join the `srcset` into a string. that can be added to the `![]()
` tag
+ srcSet = srcSet.join(', ');
+ // Set the `srcset` attribute
+ imgElem.setAttribute('srcset', srcSet);
+ // Find the new `src` for the WebP image
+
+ let webpSrc = imgSrc.replace(name, 'webp/' + encodeURIComponent(name)).replace('.png', '.webp').replace('.jpg', '.webp');
+
+ // const webpSrc = imgSrc
+ // .replace('/images/', '/images/webp/')
+ // .replace('.png', '.webp');
+ // Create a separate `source` element for the WebP with feature detection via `type`
+
+ const webpElement = document.createElement('source');
+ webpElement.setAttribute('srcset', webpSrc);
+ webpElement.setAttribute('type', 'image/webp');
+
+ // Wrap the `![]()
` and the `` into one `` tag in order for it to work
+
+ const pictureElement = document.createElement('picture');
+ pictureElement.appendChild(webpElement);
+ pictureElement.appendChild(imgElem.cloneNode());
+
+ // Replace the `![]()
` with the ``
+
+ imgElem.replaceWith(pictureElement);
+ }
+ }
+ return document.documentElement.outerHTML;
+}
+*/
+
+export const format = (formats) => {
+ return formats.forEach((format) => {
+ if (!exists(format.dist)) {
+ dir(format.dist)
+ }
+
+ // Find all files matching the glob patterns specified in `src`
+ let _files = fg.sync(format.src)
+
+ _files.forEach((file) => {
+ let filename = path.basename(file);
+ if (exists(path.resolve(`${format.dist}/${filename.replace('jpg', format.format)}`))) {
+ return;
+ }
+
+ const image = sharp(file);
+
+ // Convert to WebP via Sharp's inferencing automatically of extensions
+ image
+ .toFile(`${format.dist}/${filename.replace('jpg', format.format)}`)
+ .catch((err) => {
+ console.log(err);
+ });
+ });
+ });
+}
+
+export const getResizePatterns = (product, folder) => {
+ return [{
+ src: `${product}/${folder}/*.jpg`,
+ dist: `${product}/${folder}/80`,
+ percent: 80,
+ },
+ {
+ src: `${product}/${folder}/*.jpg`,
+ dist: `${product}/${folder}/60`,
+ percent: 60,
+ },
+ {
+ src: `${product}/${folder}/*.jpg`,
+ dist: `${product}/${folder}/40`,
+ percent: 40,
+ },
+ {
+ src: `${product}/${folder}/*.jpg`,
+ dist: `${product}/${folder}/20`,
+ percent: 20,
+ },
+ ];
+}
+
+const resize = (patterns) => {
+ return patterns.forEach((resize) => {
+ if (!exists(resize.dist)) {
+ dir(resize.dist)
+ }
+ let _files = fg.sync(resize.src)
+ _files.forEach((file) => {
+ let filename = path.basename(file)
+ const image = sharp(file)
+ if (exists(`${resize.dist}/${filename}`)) {
+ return
+ }
+ image
+ .metadata()
+ .then((metadata) => {
+ return image
+ .resize(Math.round(metadata.width * (resize.percent / 100)))
+ .png()
+ .toFile(`${resize.dist}/${filename}`)
+ .catch(logger.error);
+ })
+ .catch(logger.error)
+ })
+ })
+}
diff --git a/packages/tasks/src/mail.ts b/packages/tasks/src/mail.ts
new file mode 100644
index 00000000..b6c58901
--- /dev/null
+++ b/packages/tasks/src/mail.ts
@@ -0,0 +1,257 @@
+import * as path from 'path'
+import * as pMap from 'p-map'
+import { sync as write } from '@plastichub/fs/write'
+import { substitute } from '@plastichub/core'
+import { isArray, isObject } from '@plastichub/core/primitives'
+import { sync as read } from '@plastichub/fs/read'
+import { sync as exists } from '@plastichub/fs/exists'
+import { resolve, filesEx } from '@plastichub/osr-commons'
+import { test as send } from '@plastichub/osr-mail/lib/nodemailer'
+import {
+ MAIL_LOG_LEVEL,
+ MAIL_ENV_DEV,
+ MAIL_LANGUAGES,
+ MAIL_PROFILE,
+ MAIL_SOURCE_FILE,
+ MAIL_SRC_LANGUAGE,
+ MAIL_TEMPLATE,
+ MAIL_COMPILE_CACHE,
+ MAIL_ASSETS_ROOT,
+ MAIL_I18N_CACHE,
+ MAIL_DEFAULT_OUTPUT_PATH as SHEET_TRANSLATION_PATH
+} from './config'
+
+import { sheetTranslationTask } from './sheets'
+import { onCompiledMail } from './mail_utils'
+import { gruntOptions } from '../library'
+import { ICompileOptions } from './compile'
+import { I18N_STORE, OSR_ROOT } from './config'
+import { logger } from '../src'
+import { getOutputFileName, prepMailQueue } from './mail_utils'
+import { mailOptionSchema, enumerateHelpStrings, mailCompileSchema } from './utils'
+import { resolveContactsPath, getContacts, filterContacts } from './contacts'
+
+const getSubject = (language: string) => {
+ const subjectPath = path.resolve(resolve(`${OSR_ROOT()}/products/company/campaign/content/subject-${language}.md`))
+ if (!exists(subjectPath)) {
+ logger.error(`Cannot read subject file ${subjectPath}`)
+ return 'Default Subject'
+ }
+ return read(subjectPath) || 'Default Subject'
+}
+
+const sendOptions = (grunt, language: string = 'en') => {
+ const subject = getSubject(language)
+ return {
+ from: 'PlasticHub ',
+ transport: 'newsletter',
+ subject,
+ contacts: '',
+ filter: true,
+ query: null,
+ to: null,
+ source: `${OSR_ROOT()}/products/products/assets/newsletter/mail/mail_2024_09_public_${language}.html`,
+ ...gruntOptions(grunt)
+ }
+}
+
+const sendMailQueue = async (grunt) => {
+ const mailerOptions = sendOptions(grunt, grunt.option('lang') || 'en')
+ const source = read(path.resolve(resolve(mailerOptions.source)))
+ if (!source) {
+ logger.error(`Cannot read source file ${mailerOptions.source}`)
+ return
+ }
+ let contacts = getContacts(mailerOptions)
+ if (!contacts) {
+ logger.error(`Invalid contacts: ${resolveContactsPath(mailerOptions)}`)
+ return
+ }
+ if (!isArray(contacts) && isObject(contacts)) {
+ contacts = Object.keys(contacts).map((k) => contacts[k])
+ }
+ const total = contacts.length
+ contacts = filterContacts(grunt, contacts, mailerOptions)
+ if (mailerOptions.filter !== false) {
+ contacts = contacts.filter((contact) => contact.email && contact.email.length > 0)
+ contacts = contacts.filter((contact) => contact.status !== 'sent')
+ }
+ const sendMail = async (contact, options) => {
+ const subject = getSubject(grunt.option('lang'))
+ if (!contact.email) {
+ logger.error(`Invalid contact : ${contact}`)
+ return
+ }
+ logger.info(`Sending mail to ${contact.email}`)
+ const opts = {
+ ...options,
+ from: 'Lovebird ',
+ subject: subject,
+ transport: "newsletter",
+ to: contact.email,
+ html: substitute(source, {
+ unsubscribe_email: contact.email
+ })
+ }
+ const mail = await send(opts)
+ contact.mail = mail
+ contact.status = 'sent'
+ const contactsFile = resolveContactsPath(mailerOptions)
+ if (mailerOptions.contacts && contactsFile) {
+ const last = read(contactsFile, 'json')
+ last[contact.title] = contact
+ write(contactsFile, last)
+ }
+ logger.info(`Sent mail to ${contact.email}`)
+ return mail
+ }
+
+ if (contacts.length === 0 && mailerOptions.to) {
+ contacts = [{ email: mailerOptions.to }]
+ }
+ if (grunt.option('dry')) {
+ logger.info(`Dry : Sending ${contacts.length} mails in total, of ${total} contacts`)
+ return false
+ } else {
+ logger.debug(`Sending ${path.resolve(resolve(mailerOptions.source))} to ${contacts.length} mails`)
+ }
+
+ const mails = await pMap(contacts, async (contact) => {
+ return sendMail(contact, mailerOptions)
+ }, { concurrency: 1 })
+
+ logger.info(`Sent ${mails.length} mails`)
+ return mails
+}
+
+export const getOutputFile = (grunt, root, slug, options = {}, language: string = 'en') => {
+ const env = grunt.option('env') || MAIL_ENV_DEV
+ const isDebug = env === MAIL_ENV_DEV
+ const outFile = getOutputFileName(isDebug, slug, language)
+ const output = path.resolve(path.join(root, outFile))
+ return output
+}
+
+export const mailCompileOptions = (grunt: any, root, slug, options = {}, language: string = 'en') => {
+ const template = grunt.option('template') ?
+ path.resolve(resolve(grunt.option('template'))) : path.join(root, slug, MAIL_TEMPLATE)
+
+ const env = grunt.option('env') || MAIL_ENV_DEV
+ const isDebug = env === MAIL_ENV_DEV
+ const outFile = getOutputFileName(isDebug, slug, language)
+ const output = grunt.option('output') ?
+ path.resolve(resolve(grunt.option('output'))) : path.resolve(path.join(root, outFile))
+
+ root = path.join(root, slug)
+
+ const onCompiled = async (src, dst, content) => {
+ const ret = await onCompiledMail(src, dst, content)
+ if (grunt.option('send') && !grunt.option('contacts')) {
+ const opts = {
+ from: 'Lovebird ',
+ to: grunt.option('to') || 'cgoflyn@gmail.com',
+ html: substitute(ret, {
+ unsubscribe_email: 'cgoflyn@gmail.com'
+ }),
+ subject: `Test Mail : - ${language} : - ` + Math.random(),
+ transport: "newsletter",
+ ...gruntOptions(grunt)
+ }
+ await send(opts)
+ }
+ return ret
+ }
+
+ const ret: ICompileOptions = {
+ cache: MAIL_COMPILE_CACHE,
+ root,
+ cwd: root,
+ env,
+ format: 'html',
+ language: 'osr',
+ logLevel: grunt.option('logLevel') || MAIL_LOG_LEVEL,
+ module: 'plastichub-mail',
+ profile: MAIL_PROFILE as any,
+ template,
+ output,
+ // onCompiled: !isDebug || grunt.option('send') ? onCompiled : undefined,
+ variables: {
+ cwd: root,
+ root,
+ targetLanguage: language as any,
+ sourceLanguage: MAIL_SRC_LANGUAGE,
+ i18n: I18N_STORE(OSR_ROOT(), language),
+ ...gruntOptions(grunt)
+ },
+ ...options,
+ ...gruntOptions(grunt)
+ }
+ return ret
+}
+
+export const mailSendTask = (grunt, root, directory, options: any = {}, newsletter_tasks) => {
+ grunt.registerTask(`prepare-mail-contacts`, async () => {
+ prepMailQueue(grunt, root, directory, options)
+ })
+ grunt.registerTask(`send-mail-queue`, "help", async function () {
+ this.async()
+ try {
+ await sendMailQueue(grunt)
+ } catch (e) {
+ logger.error(`Error sending mail : ${e.message}`, e.stack)
+ }
+ })
+ if (grunt.option('describe')) {
+ grunt.registerTask(`send-mail`, () => {
+ logger.setSettings({
+ displayFunctionName: false,
+ displayInstanceName: false,
+ displayLogLevel: false,
+ displayLoggerName: false,
+ displayDateTime: false,
+ displayFilePath: "hidden"
+ })
+ logger.debug(`\nOptions : ${mailOptionSchema._def.description}`)
+ logger.info(`send mail options: Directory:${directory}`, enumerateHelpStrings(mailOptionSchema, [], logger))
+
+ logger.debug(`\nOptions : ${mailCompileSchema(grunt)._def.description}`)
+ logger.info(`send compile schema options:`, enumerateHelpStrings(mailCompileSchema(grunt), [], logger))
+ })
+ return
+ } else {
+ grunt.registerTask(`send-mail`, [`mail-tasks`, "send-mail-queue"])
+ }
+}
+
+export const mailTask = (grunt, root, directory, options: any = {}, newsletter_tasks) => {
+ const mailAssets = filesEx(MAIL_ASSETS_ROOT(), '*-en.xlsx')
+ const mailAssetTasks = []
+ const languages: string[] = grunt.option('languages') ? grunt.option('languages').split(',') : MAIL_LANGUAGES
+ sheetTranslationTask(grunt, 'mail-assets',
+ mailAssets, languages, mailAssetTasks,
+ {
+ dst: SHEET_TRANSLATION_PATH,
+ cache: MAIL_I18N_CACHE,
+ query: "$[*][0,1,2,3,4,5]"
+ })
+
+ ////////////////////////////////
+ // Content Compile Tasks
+ const config = {}
+ const slug = directory.replace(/\//g, '-')
+ const extraOptions = {}
+ const source = grunt.option('source') ?
+ path.resolve(resolve(grunt.option('source'))) : path.join(root, directory, MAIL_SOURCE_FILE)
+ languages.forEach((lang) => {
+ config[`${slug}-${lang}`] = {
+ src: [source],
+ options: mailCompileOptions(grunt, root, directory, extraOptions, lang)
+ }
+ grunt.extendConfig({ compile: config })
+ write('./tmp/compile-mail/options.json', config)
+ grunt.registerTask(`${slug}-${lang}`, [`mail-assets-${lang}`, `compile:${slug}-${lang}`])
+ newsletter_tasks.push(`compile:${slug}-${lang}`)
+ })
+ grunt.registerTask(`mail-tasks`, newsletter_tasks)
+}
+
diff --git a/packages/tasks/src/mail_utils.ts b/packages/tasks/src/mail_utils.ts
new file mode 100644
index 00000000..92060095
--- /dev/null
+++ b/packages/tasks/src/mail_utils.ts
@@ -0,0 +1,85 @@
+import * as path from 'path'
+import * as juice from 'juice'
+import { minify } from 'html-minifier-terser'
+
+import { filesEx } from '@plastichub/osr-commons/_glob'
+import { sync as write } from '@plastichub/fs/write'
+import * as XLSX from 'xlsx'
+import { logger } from '../src'
+import { gruntOptions } from '../library'
+
+import {
+ MAIL_OUTPUT_DIR,
+ MAIL_OUTPUT_FILE_EXT,
+ MAIL_OUTPUT_FILE_NAME,
+ MAIL_OUTPUT_FILE_NAME_PROD,
+ PRODUCT_ROOT
+} from './config'
+
+type TableData = (string | null)[][]
+
+export const prepMailQueue = async (grunt, root, directory, options: any = {},) => {
+
+ logger.info(`Sending mail queue from ${directory}`)
+
+ const mailRoot = path.join(root, directory)
+ const mailContentRoot = path.join(mailRoot, 'data')
+ const contactFiles = filesEx(mailContentRoot, '*.xlsx')
+ contactFiles.forEach((file) => {
+ const workbook = XLSX.readFile(file)
+ const worksheet = workbook.Sheets[workbook.SheetNames[0]]
+ const raw_data: any[] = XLSX.utils.sheet_to_json(worksheet, { header: 1, blankrows: false, raw: false, skipHidden: false })
+ const contacts = convertToJSON(raw_data)
+ const dst = path.join(mailContentRoot, path.parse(file).name + '.json')
+ logger.info(`Writing contacts from ${file} to ${dst}`)
+ write(dst, JSON.stringify(contacts, null, 2))
+ })
+}
+
+
+export const convertToJSON = (data: TableData): object[] => {
+ const [fields, ...rows] = data;
+ return rows.map(row => {
+ const jsonObject: any = {};
+ row.forEach((value, index) => {
+ let fieldName = fields[index];
+ if (fieldName?.toLowerCase().includes('mail')) {
+ fieldName = 'email';
+ } else if (fieldName?.toLowerCase().includes('name')) {
+ fieldName = 'name';
+ }
+ jsonObject[fieldName] = value;
+ });
+ return jsonObject;
+ });
+}
+
+export const sendOptions = (grunt, root, slug, options = {}, language: string = 'en', contacts) => {
+ return {
+ from: 'PlasticHub ',
+ transport: 'newsletter',
+ subject: 'New Sheetpresses, Extruders, Shredders and Injectors',
+ contacts,
+ source: `${PRODUCT_ROOT()}/${MAIL_OUTPUT_DIR}/${MAIL_OUTPUT_FILE_NAME}_public_${language}.html`,
+ ...gruntOptions(grunt)
+ }
+}
+export const getOutputFileName = (isDebug: boolean, slug: string, lang: string = 'en') => {
+ return isDebug ?
+ `${MAIL_OUTPUT_DIR}/${MAIL_OUTPUT_FILE_NAME}_${lang}${MAIL_OUTPUT_FILE_EXT}` :
+ `${MAIL_OUTPUT_DIR}/${MAIL_OUTPUT_FILE_NAME_PROD}_${lang}${MAIL_OUTPUT_FILE_EXT}`
+}
+
+export const mailDefault = async (content) => {
+ const options: juice.Options = {}
+ content = juice(content, options)
+ content = await minify(content, {
+ collapseWhitespace: true,
+ removeComments: true,
+ minifyCSS: true,
+ minifyJS: true
+ })
+ return content
+}
+export const onCompiledMail = async (src, dst, content) =>
+ mailDefault(content)
\ No newline at end of file
diff --git a/packages/tasks/src/newsletter.ts b/packages/tasks/src/newsletter.ts
new file mode 100644
index 00000000..f4638b73
--- /dev/null
+++ b/packages/tasks/src/newsletter.ts
@@ -0,0 +1,49 @@
+import * as path from 'path'
+import { contentTasks, ICompileOptions, ICompileTaskOptions } from './compile'
+import { option } from '../library'
+import { logger } from '../src/'
+import {
+ I18N_SOURCE_LANGUAGE,
+ NEWSLETTER_COMPILE_CACHE,
+ NEWSLETTER_DEFAULT_ENV,
+ NEWSLETTER_LOG_LEVEL} from './config'
+
+export const newsletterTasks = (
+ grunt,
+ taskPrefix = 'newsletter',
+ root,
+ template,
+ src,
+ dst,
+ taskOptions: ICompileTaskOptions = {},
+ compilerOptions: ICompileOptions = {}
+) => {
+
+ logger.info(`Registering newsletter tasks for ${taskPrefix}`)
+ const env = option('env', {}, grunt, NEWSLETTER_DEFAULT_ENV)
+ const newsletter_tasks = contentTasks(grunt,
+ {
+ sourceLanguage: I18N_SOURCE_LANGUAGE,
+ src: [path.join(root, src)],
+ taskPrefix,
+ ...taskOptions
+ },
+ {
+ cache: option('cache', {}, grunt, NEWSLETTER_COMPILE_CACHE),
+ root,
+ env,
+ logLevel: option('logLevel', {}, grunt, NEWSLETTER_LOG_LEVEL),
+ output: dst,
+ template:path.join(root, template),
+ variables: {
+ env,
+ prefix: env,
+ root,
+ targetLanguage: I18N_SOURCE_LANGUAGE,
+ sourceLanguage: I18N_SOURCE_LANGUAGE
+ },
+ ...compilerOptions
+ })
+ grunt.registerTask(taskPrefix, Object.keys(newsletter_tasks).map((lang: any) => newsletter_tasks[lang].taskName))
+ return newsletter_tasks
+}
\ No newline at end of file
diff --git a/packages/tasks/src/npm.ts b/packages/tasks/src/npm.ts
new file mode 100644
index 00000000..8090ab46
--- /dev/null
+++ b/packages/tasks/src/npm.ts
@@ -0,0 +1,290 @@
+import * as semver from 'semver'
+import * as child_process from 'child_process'
+let DESC = 'Increment the version, commit, tag and push.'
+export const register = (grunt) => {
+ grunt.registerTask('bump', DESC, function(versionType, incOrCommitOnly) {
+ const opts = this.options({
+ bumpVersion: true,
+ commit: true,
+ commitFiles: ['package.json'], // '-a' for all files
+ commitMessage: 'Release v%VERSION%',
+ createTag: true,
+ dryRun: false,
+ files: ['package.json'],
+ gitCommitOptions: '',
+ gitDescribeOptions: '--tags --always --abbrev=1 --dirty=-d',
+ globalReplace: false,
+ prereleaseName: false,
+ metadata: '',
+ push: true,
+ pushTo: 'upstream',
+ regExp: false,
+ setVersion: false,
+ tagMessage: 'Version %VERSION%',
+ tagName: 'v%VERSION%',
+ updateConfigs: [], // array of config properties to update (with files)
+ versionType: false
+ });
+
+ if (versionType === 'bump-only' || versionType === 'commit-only') {
+ incOrCommitOnly = versionType;
+ versionType = '';
+ }
+ versionType = versionType || opts.versionType;
+
+ const dryRun = grunt.option('dry-run') || opts.dryRun;
+
+ let setVersion = grunt.option('setversion') || opts.setVersion;
+ if (setVersion && !semver.valid(setVersion)) {
+ setVersion = false;
+ }
+
+ let globalVersion; // when bumping multiple files
+ let gitVersion; // when bumping using `git describe`
+
+ let VERSION_REGEXP = (typeof opts.regExp === 'function') ? opts.regExp(opts.prereleaseName) : opts.regExp || new RegExp(
+ '([\'|\"]?version[\'|\"]?[ ]*:[ ]*[\'|\"]?)(\\d+\\.\\d+\\.\\d+(-' +
+ opts.prereleaseName +
+ '\\.\\d+)?(-\\d+)?)[\\d||A-a|.|-]*([\'|\"]?)', 'i'
+ );
+ if (opts.globalReplace) {
+ VERSION_REGEXP = new RegExp(VERSION_REGEXP.source, 'gi');
+ }
+
+ const done = this.async();
+ const queue = [];
+ const next = function() {
+ if (!queue.length) {
+ grunt.config.set('bump.version', globalVersion);
+ return done();
+ }
+ queue.shift()();
+ };
+ const runIf = function(condition, behavior) {
+ if (condition) {
+ queue.push(behavior);
+ }
+ };
+
+ if (dryRun) {
+ grunt.log.writeln('Running grunt-bump in dry mode!');
+ }
+
+ if (incOrCommitOnly === 'bump-only') {
+ grunt.verbose.writeln('Only incrementing the version.');
+
+ opts.commit = false;
+ opts.createTag = false;
+ opts.push = false;
+ }
+
+ if (incOrCommitOnly === 'commit-only') {
+ grunt.verbose.writeln('Only committing/tagging/pushing.');
+
+ opts.bumpVersion = false;
+ }
+
+ // GET VERSION FROM GIT
+ runIf(opts.bumpVersion && versionType === 'git', function() {
+ child_process.execFile('git describe ' + opts.gitDescribeOptions, function(err, stdout) {
+ if (err) {
+ grunt.fatal('Can not get a version number using `git describe`');
+ }
+ gitVersion = stdout.trim();
+ next();
+ });
+ });
+
+ // BUMP ALL FILES
+ runIf(opts.bumpVersion, function() {
+ grunt.file.expand(opts.files).forEach(function(file, idx) {
+ let version = null;
+ const content = grunt.file.read(file).replace(
+ VERSION_REGEXP,
+ function(match, prefix, parsedVersion, namedPre, noNamePre, suffix) {
+ const type = versionType === 'git' ? 'prerelease' : versionType;
+ version = setVersion || semver.inc(
+ parsedVersion, type || 'patch', gitVersion || opts.prereleaseName
+ );
+ if (opts.metadata) {
+ if (!/^([0-9a-zA-Z-]+\.{0,1})*$/.test(opts.metadata)) {
+ grunt.fatal(
+ 'Metadata can only contain letters, numbers, dashes ' +
+ '(-) and dots (.)'
+ );
+ }
+ version += '+' + opts.metadata;
+ }
+ return prefix + version + (suffix || '');
+ }
+ );
+
+ if (!version) {
+ grunt.fatal('Can not find a version to bump in ' + file);
+ }
+
+ const logMsg = 'Version bumped to ' + version + ' (in ' + file + ')';
+ if (!dryRun) {
+ grunt.file.write(file, content);
+ grunt.log.ok(logMsg);
+ } else {
+ grunt.log.ok('bump-dry: ' + logMsg);
+ }
+
+ if (!globalVersion) {
+ globalVersion = version;
+ } else if (globalVersion !== version) {
+ grunt.warn('Bumping multiple files with different versions!');
+ }
+
+ const configProperty = opts.updateConfigs[idx];
+ if (!configProperty) {
+ return;
+ }
+
+ const cfg = grunt.config(configProperty);
+ if (!cfg) {
+ return grunt.warn(
+ 'Can not update "' + configProperty + '" config, it does not exist!'
+ );
+ }
+
+ cfg.version = version;
+ grunt.config(configProperty, cfg);
+ grunt.log.ok(configProperty + '\'s version updated');
+ });
+ next();
+ });
+
+
+ // when only committing, read the version from package.json / pkg config
+ runIf(!opts.bumpVersion, function() {
+ const configVersion = grunt.config.get('bump.version');
+
+ if (configVersion) {
+ globalVersion = configVersion;
+ }
+ else if (opts.updateConfigs.length) {
+ globalVersion = grunt.config(opts.updateConfigs[0]).version;
+ } else {
+ globalVersion = grunt.file.readJSON(opts.files[0]).version;
+ }
+
+ next();
+ });
+
+
+ // COMMIT
+ runIf(opts.commit, function() {
+ const commitMessage = opts.commitMessage.replace(
+ '%VERSION%', globalVersion
+ );
+ let cmd = 'git commit ' + opts.gitCommitOptions + ' ' + opts.commitFiles.join(' ');
+ cmd += ' -m "' + commitMessage + '"';
+
+ if (dryRun) {
+ grunt.log.ok('bump-dry: ' + cmd);
+ next();
+ } else {
+ child_process.execFile(cmd, function(err, stdout, stderr) {
+ if (err) {
+ grunt.fatal('Can not create the commit:\n ' + stderr);
+ }
+ grunt.log.ok('Committed as "' + commitMessage + '"');
+ next();
+ });
+ }
+ });
+
+
+ // CREATE TAG
+ runIf(opts.createTag, function() {
+ const tagName = opts.tagName.replace('%VERSION%', globalVersion);
+ const tagMessage = opts.tagMessage.replace('%VERSION%', globalVersion);
+
+ const cmd = 'git tag -a ' + tagName + ' -m "' + tagMessage + '"';
+ if (dryRun) {
+ grunt.log.ok('bump-dry: ' + cmd);
+ next();
+ } else {
+ child_process.execFile(cmd , function(err, stdout, stderr) {
+ if (err) {
+ grunt.fatal('Can not create the tag:\n ' + stderr);
+ }
+ grunt.log.ok('Tagged as "' + tagName + '"');
+ next();
+ });
+ }
+ });
+
+
+ // PUSH CHANGES
+ runIf(opts.push, function() {
+ let cmd;
+
+ if (opts.push === 'git' && !opts.pushTo) {
+ cmd = 'git push';
+ if (dryRun) {
+ grunt.log.ok('bump-dry: ' + cmd);
+ next();
+ } else {
+ child_process.execFile(cmd, function(err, stdout, stderr) {
+ if (err) {
+ grunt.fatal(
+ 'Can not push to the git default settings:\n ' + stderr
+ );
+ }
+ grunt.log.ok('Pushed to the git default settings');
+ next();
+ });
+ }
+
+ return;
+ }
+
+ child_process.execFile('git rev-parse --abbrev-ref HEAD', function(err, ref, stderr) {
+ if (err) {
+ grunt.fatal('Can not get ref for HEAD:\n' + stderr);
+ }
+
+ cmd = [];
+
+ if (opts.push === true || opts.push === 'branch') {
+ cmd.push('git push ' + opts.pushTo + ' ' + ref.trim());
+ }
+
+ if (opts.createTag && (opts.push === true || opts.push === 'tag')) {
+ const tagName = opts.tagName.replace('%VERSION%', globalVersion);
+ cmd.push('git push ' + opts.pushTo + ' ' + tagName);
+ }
+
+ cmd = cmd.join(' && ');
+
+ if (dryRun) {
+ grunt.log.ok('bump-dry: ' + cmd);
+ next();
+ } else {
+ child_process.execFile(cmd, function(err, stdout, stderr) {
+ if (err) {
+ grunt.fatal('Can not push to ' + opts.pushTo + ':\n ' + stderr);
+ }
+ grunt.log.ok('Pushed to ' + opts.pushTo);
+ next();
+ });
+ }
+ });
+ });
+
+ next();
+ });
+
+
+ // ALIASES
+ DESC = 'Increment the version only.';
+ grunt.registerTask('bump-only', DESC, function(versionType) {
+ grunt.task.run('bump:' + (versionType || '') + ':bump-only');
+ });
+
+ DESC = 'Commit, tag, push without incrementing the version.';
+ grunt.registerTask('bump-commit', DESC, 'bump::commit-only');
+}
diff --git a/packages/tasks/src/sheets.ts b/packages/tasks/src/sheets.ts
new file mode 100644
index 00000000..f0512231
--- /dev/null
+++ b/packages/tasks/src/sheets.ts
@@ -0,0 +1,93 @@
+import { sanitize } from '@plastichub/osr-i18n/_cli'
+
+import { CONFIG_DEFAULT } from '@plastichub/osr-commons'
+
+
+import { IOptions as IOptionsI18n } from '@plastichub/osr-i18n/types'
+import { translate } from '@plastichub/osr-i18n/lib/translate'
+import * as pMap from 'p-map'
+
+import {
+ I18N_SOURCE_LANGUAGE, I18N_STORE,
+ MAIL_DEFAULT_OUTPUT_PATH,
+ OSR_ROOT
+} from './config'
+
+import { logger } from '../src'
+
+export const defaultSheetOptions = (srcLang, dstLang, dst: string, logLevel: string, options: {} = {}) => {
+ const i18nOptions: IOptionsI18n = {
+ srcLang,
+ dstLang,
+ store: I18N_STORE(OSR_ROOT(), dstLang),
+ dst,
+ cache: true,
+ logLevel,
+ ...options
+ }
+ return i18nOptions
+}
+
+export const translateSheets = async (
+ languages: string[],
+ files: string[],
+ srcLang: string,
+ dstLanguage: string,
+ query: string = "$[*][0,1,2,3,4]",
+ dst: string = MAIL_DEFAULT_OUTPUT_PATH,
+ logLevel = 'info',
+ options: any = {}) => {
+
+ const config: any = CONFIG_DEFAULT()
+ if (dstLanguage === I18N_SOURCE_LANGUAGE) {
+ return
+ }
+ return await pMap(languages, async (dstLanguage) => {
+ return await pMap(files, async (src) => {
+ const i18nOptions: IOptionsI18n = {
+ srcLang: srcLang,
+ dstLang: dstLanguage,
+ src: src,
+ store: I18N_STORE(OSR_ROOT(), dstLanguage),
+ dst: dst,
+ query: query,
+ cache: true,
+ api_key: config.deepl.auth_key,
+ logLevel: logLevel,
+ ...options
+ }
+ logger.debug('Translate Sheet ' + src + ' ' + dstLanguage, i18nOptions)
+ const ret = await translate(sanitize(i18nOptions) as any)
+ return ret
+ })
+ })
+}
+export const sheetTranslationTask = (grunt, slug: string, files: string[], languages: string[], translationTasks: string[], options: {} = {}) => {
+ const config = {}
+ const key: any = (CONFIG_DEFAULT() as any).deepl.auth_key
+ languages.forEach((lang: string) => {
+ config[`${slug}-${lang}`] = {
+ src: files,
+ options: defaultSheetOptions(I18N_SOURCE_LANGUAGE, lang, `${OSR_ROOT()}/content/${lang}`, 'warn', { api_key: key, ...options })
+ }
+ grunt.extendConfig({ i18n: config })
+ grunt.registerTask(`${slug}-${lang}`, `i18n:${slug}-${lang}`)
+ translationTasks.push(`i18n:${slug}-${lang}`)
+ })
+ grunt.registerTask(`${slug}-tasks`, translationTasks)
+}
+
+export const register = (grunt) => {
+ grunt.registerMultiTask('sheets-i18n', 'Translate Sheets ', async function () {
+ const done = this.async()
+ const task_options = this.data.options
+ // const cwd = path.resolve(option('cwd', task_options, grunt, process.cwd()))
+
+ return new Promise((resolve) => {
+ if (!task_options.watchContent) {
+ resolve(true)
+ done()
+ }
+ })
+ })
+ }
\ No newline at end of file
diff --git a/packages/tasks/src/sshexec.ts b/packages/tasks/src/sshexec.ts
new file mode 100644
index 00000000..a430499a
--- /dev/null
+++ b/packages/tasks/src/sshexec.ts
@@ -0,0 +1,156 @@
+import { Client } from 'ssh2'
+import { isArray } from '@plastichub/core/primitives'
+import { CONFIG_DEFAULT } from '@plastichub/osr-commons/config'
+import { logger } from '../src'
+import { option } from '../library'
+
+const parseConnectionOptions = function (options: any) {
+ const connectionOptions: any = {
+ host: options.host,
+ port: options.port,
+ username: options.user,
+ readyTimeout: options.readyTimeout,
+ agentForward: options.agentForward
+ }
+
+ if (options.privateKey) {
+ connectionOptions.privateKey = options.privateKey.trim();
+
+ if (options.passphrase) {
+ connectionOptions.passphrase = options.passphrase.trim();
+ }
+ }
+ else if (options.password) {
+ connectionOptions.password = options.password;
+ if (options.agent) {
+ connectionOptions.agent = options.agent;
+ }
+ } else {
+ connectionOptions.agent = options.agent;
+ }
+
+ return connectionOptions
+}
+
+const exce = async (commands: string[], options: any) => {
+
+ return new Promise((resolve, reject) => {
+ const c = new Client()
+ const { debug, verbose } = options
+ c.on('keyboard-interactive', function () {
+ const prompts = arguments[3]
+ const reply = arguments[4]
+ prompts.forEach(function (question) {
+ const msg = question.prompt.toLowerCase()
+ if (msg.indexOf('password') !== -1) {
+ reply([options.password])
+ }
+ })
+ })
+
+ c.on('connect', () => logger.info('Connection :: connect'))
+ c.on('ready', () => {
+ logger.info('Connection :: ready')
+ execCommand()
+ })
+ c.on('error', (err) => logger.error('Connection :: error :: ' + err) && resolve(false))
+ c.on('end', () => logger.info('Connection :: end') && resolve(false))
+ const execCommand = () => {
+ if (commands.length === 0) {
+ c.end()
+ } else {
+ const command = commands.shift()
+ logger.info('Executing :: ' + command)
+ c.exec(command, options, function (err, stream) {
+ if (err) {
+ reject(err)
+ }
+ let out
+
+ stream.on('data', (data, extended) => {
+ out = String(data);
+ if (extended === 'stderr') {
+ if (!options.suppressRemoteErrors) {
+ logger.warn(out);
+ }
+ else {
+ logger.warn(out);
+ }
+ } else {
+ logger.info(out)
+ }
+ })
+
+ stream.on('end', () => {
+ resolve(out)
+ })
+
+ stream.on('close', (code, signal) => {
+ debug && logger.info('Stream :: close :: code: ' + code + ', signal: ' + signal)
+ if (!options.ignoreErrors && code !== 0) {
+ logger.error('Error executing task ' + command, code, signal)
+ c.end()
+ reject({ signal, code })
+ } else {
+ execCommand()
+ }
+ })
+ })
+ }
+ }
+
+ const connectionOptions = parseConnectionOptions(options)
+ connectionOptions.tryKeyboard = true;
+ const proxyHost = (options.proxy || {}).host
+ if (proxyHost) {
+
+ const proxyConnectionOptions = parseConnectionOptions(options.proxy)
+ const proxyConnection = new Client()
+ proxyConnection.on('connect', function () {
+ logger.info('Proxy connection :: connect')
+ })
+ proxyConnection.on('error', function (err) {
+ logger.error('Proxy connection :: error :: ' + err)
+ })
+ proxyConnection.on('ready', function () {
+ logger.info('Proxy connection :: ready')
+ proxyConnection.exec('nc ' + connectionOptions.host + ' ' + connectionOptions.port, function (err, stream) {
+ if (err) {
+ proxyConnection.end()
+ reject(err)
+ }
+ connectionOptions.sock = stream;
+ c.connect(connectionOptions)
+ })
+ })
+ proxyConnection.connect(proxyConnectionOptions)
+ }
+ else {
+ c.connect(connectionOptions)
+ }
+ })
+}
+
+export const register = (grunt) => {
+ grunt.registerMultiTask('sshexec', 'Runs commands on SSH', async function () {
+ let done = this.async()
+ const task_options = this.data || {}
+ const sshConfig = (CONFIG_DEFAULT() as any || {}).ssh || {}
+ const opts = {
+ ...sshConfig,
+ debug: option('debug', task_options, grunt),
+ verbose: option('verbose', task_options, grunt),
+ port: option('port', task_options, grunt, sshConfig.port),
+ host: option('host', task_options, grunt, sshConfig.host),
+ user: option('user', task_options, grunt, sshConfig.user),
+ password: option('password', task_options, grunt, sshConfig.password),
+ logLevel: option('logLevel', task_options, grunt,'warn')
+ }
+ logger.setSettings({ minLevel: opts.logLevel })
+ logger.info('Git - task data ', this.data)
+ let commands: string[] = isArray(this.data.commands) ? this.data.commands : [this.data.commands]
+ const ret = await exce(commands, opts)
+ logger.info(`Exce : ${[this.data.command].join('\n')} : `, ret)
+ done()
+ })
+}
diff --git a/packages/tasks/src/sync.ts b/packages/tasks/src/sync.ts
new file mode 100644
index 00000000..1ddc168e
--- /dev/null
+++ b/packages/tasks/src/sync.ts
@@ -0,0 +1,37 @@
+
+import { isArray } from '@plastichub/core/primitives'
+import { sync } from '@plastichub/osr-sync/lib/sync'
+import { resolve } from '@plastichub/osr-commons'
+import { option } from '../library'
+import { logger } from '../src'
+
+export const register = (grunt) => {
+ grunt.registerMultiTask('sync', 'Synchronizes folders, using osr-sync', function () {
+ const done = this.async()
+ const task_options = this.data || {}
+ let source: string[] = isArray(this.data.src) ? this.data.src : [this.data.src]
+ const variables = { ...task_options.variables || {} }
+ logger.setSettings({ minLevel: option('logLevel', task_options, grunt, 'warn') })
+ source = source.map(f => resolve(f, false, variables))
+ const options = {
+ source,
+ target: resolve(option('target', task_options, grunt), variables),
+ root: option('root', task_options, grunt),
+ clear: option('clear', task_options, grunt),
+ debug: false,
+ verbose: false,
+ //debug: option('debug', task_options, grunt),
+ //verbose: option('verbose', task_options, grunt, false),
+ profile: option('profile', task_options, grunt),
+ logLevel: option('logLevel', task_options, grunt, 'warn'),
+ variables: variables
+ }
+ try {
+ sync(options)
+ } catch (e) {
+ logger.error(`Error while syncing : ${source.join('\n')} : ${e.messsage}`, e)
+ }
+ done()
+ return true
+ })
+}
diff --git a/packages/tasks/src/utils.ts b/packages/tasks/src/utils.ts
new file mode 100644
index 00000000..4aa8cb1b
--- /dev/null
+++ b/packages/tasks/src/utils.ts
@@ -0,0 +1,186 @@
+import { z, ZodObject, ZodTypeAny } from "zod"
+
+import { MAIL_SOURCE_FILE } from "./config"
+
+
+export const cleanArray = (arr: any[]): any[] => {
+ // Use a Set to eliminate duplicates
+ const uniqueItems = Array.from(new Set(arr.map(item => JSON.stringify(item))))
+ .map(item => JSON.parse(item))
+
+ return uniqueItems.filter(item => {
+ if (Array.isArray(item)) {
+ return item.length > 0; // Exclude empty arrays
+ } else if (typeof item === 'object' && item !== null) {
+ return Object.keys(item).length > 0; // Exclude empty objects
+ } else if (typeof item === 'string') {
+ // Remove URL parameters from strings
+ return item
+ }
+ return true; // Keep other types (e.g., numbers, etc.)
+ }).map(item => {
+ // Apply the URL cleanup on strings if they haven't been filtered out
+ if (typeof item === 'string') {
+ return item
+ }
+ return item
+ })
+}
+
+export const mailOptionSchema = z.object({
+ from: z
+ .string()
+ .default("'PlasticHub-Barcelona '")
+ .describe("The sender email address formatted as a string."),
+ transport: z
+ .string()
+ .default("newsletter")
+ .describe("The transport profile, e.g., 'newsletter'."),
+ subject: z
+ .string()
+ .default("Mejora tu CarpinterĂa: Prensas de Planchas, Extrusoras e Inyectores para Procesamiento de Plástico")
+ .describe("The subject of the email being sent."),
+ contacts: z
+ .string()
+ .default("${OSR_ROOT}/osr-directory/meta/index.json")
+ .describe("Path to the contacts directory or file."),
+ filter: z
+ .boolean()
+ .default(true)
+ .describe("Indicates whether a filter should be applied: true filters out already sent emails."),
+ query: z
+ .string()
+ .default("QT_CARPENTERS_SPAIN_ALL_EMAIL")
+ .describe("The query string used to select recipients. From profile or string"),
+ to: z
+ .string()
+ .nullable()
+ .default(null)
+ .describe("Optional recipient address; can be null if not specified."),
+ send: z
+ .boolean()
+ .default(true)
+ .describe("Indicates whether the email should be sent."),
+ dry: z
+ .boolean()
+ .default(false)
+ .describe("For testing purposes"),
+ logLevel: z
+ .string()
+ .default("debug")
+ .describe("The level of logging detail, e.g., 'debug', 'info', 'error'.")
+}, { description: "Options for sending an email." })
+
+export const compileVariablesSchema = (grunt) => z.object({
+ cwd: z
+ .string()
+ .default("C:\\Users\\mc007\\Desktop\\osr\\products\\company\\mail\\2024\\08")
+ .describe("The current working directory for the process."),
+ root: z
+ .string()
+ .default("C:\\Users\\mc007\\Desktop\\osr\\products\\company\\mail\\2024\\08")
+ .describe("The root directory for the project."),
+ targetLanguage: z
+ .string()
+ .default("es")
+ .describe("The target language code for the output."),
+ sourceLanguage: z
+ .string()
+ .default("en")
+ .describe("The source language code for the input."),
+ i18n: z
+ .string()
+ .default("C:\\Users\\mc007\\Desktop\\osr/i18n-store/store-es.json")
+ .describe("The path to the internationalization (i18n) store file.")
+});
+
+export const mailCompileSchema = (grunt) => z.object({
+ cache: z
+ .boolean()
+ .default(false)
+ .describe("Indicates whether caching is enabled."),
+ cwd: z
+ .string()
+ .default("C:\\Users\\mc007\\Desktop\\osr\\products\\company\\mail\\2024\\08")
+ .describe("The current working directory for the process."),
+ env: z
+ .string()
+ .default("hugo-release")
+ .describe("The environment for the process, e.g., 'hugo-release'."),
+ format: z
+ .string()
+ .default("html")
+ .describe("The format of the output file."),
+ language: z
+ .string()
+ .default("osr")
+ .describe("The language code or identifier used for processing."),
+ logLevel: z
+ .string()
+ .default("debug")
+ .describe("The level of logging detail, e.g., 'debug', 'info', 'error'."),
+ module: z
+ .string()
+ .default("plastichub-mail")
+ .describe("The module being used for the process."),
+ profile: z
+ .string()
+ .default("${OSR_ROOT}/osr-templates/osrl/.osrl.json")
+ .describe("The path to the profile configuration file."),
+ root: z
+ .string()
+ .default("C:\\Users\\mc007\\Desktop\\osr\\products\\company\\mail\\2024\\08")
+ .describe("The root directory for the project."),
+ sourceLanguage: z
+ .string()
+ .default("en")
+ .describe("The source language code for the input."),
+ targetLanguage: z
+ .string()
+ .default("en")
+ .describe("The target language code for the output."),
+ template: z
+ .string()
+ .default("C:\\Users\\mc007\\Desktop\\osr\\products\\company\\mail\\2024\\08\\root.osr")
+ .describe("The path to the template file being used."),
+ output: z
+ .string()
+ .default("C:\\Users\\mc007\\Desktop\\osr\\products\\products\\assets\\newsletter\\mail\\mail_2024_09_public_es.html")
+ .describe("The path to the output file."),
+ source: z
+ .string()
+ .default(MAIL_SOURCE_FILE || grunt.option('source'))
+ .describe("The path to the source file."),
+ variables: compileVariablesSchema(grunt).describe("An object containing variable paths and language codes for processing.")
+})
+
+export const enumerateHelpStrings = (schema: ZodTypeAny, path: string[] = [], logger: any): void => {
+ if (schema instanceof ZodObject) {
+ for (const key in schema.shape) {
+ const nestedSchema = schema.shape[key];
+ enumerateHelpStrings(nestedSchema, [...path, key], logger)
+ }
+ } else {
+ const description = schema._def.description
+ const fieldDef = schema._def
+ const innerType = fieldDef.innerType
+
+ let type: 'string' | 'boolean' | 'number' | undefined
+ if (innerType._def.typeName === 'ZodString') {
+ type = 'string'
+ } else if (innerType._def.typeName === 'ZodBoolean') {
+ type = 'boolean'
+ } else if (innerType._def.typeName === 'ZodNumber') {
+ type = 'number'
+ }
+ let defaultValue = fieldDef.defaultValue
+ defaultValue = defaultValue !== undefined ? defaultValue() : undefined
+ if (type === 'boolean') {
+ defaultValue = defaultValue === 'true'
+ }
+
+ if (description) {
+ logger.debug(`\t ${path.join('.')}: ${description} \t Default: ${defaultValue}`)
+ }
+ }
+}
\ No newline at end of file
diff --git a/packages/ui/package-lock.json b/packages/ui/package-lock.json
index 38bd46b2..2d5b22f0 100644
--- a/packages/ui/package-lock.json
+++ b/packages/ui/package-lock.json
@@ -14259,7 +14259,6 @@
"resolved": "https://registry.npmjs.org/prosemirror-model/-/prosemirror-model-1.25.4.tgz",
"integrity": "sha512-PIM7E43PBxKce8OQeezAs9j4TP+5yDpZVbuurd1h5phUxEKIu+G2a+EUZzIC5nS1mJktDJWzbqS23n1tsAf5QA==",
"license": "MIT",
- "peer": true,
"dependencies": {
"orderedmap": "^2.0.0"
}
@@ -14293,7 +14292,6 @@
"resolved": "https://registry.npmjs.org/prosemirror-state/-/prosemirror-state-1.4.4.tgz",
"integrity": "sha512-6jiYHH2CIGbCfnxdHbXZ12gySFY/fz/ulZE333G6bPqIZ4F+TXo9ifiR86nAHpWnfoNjOb3o5ESi7J8Uz1jXHw==",
"license": "MIT",
- "peer": true,
"dependencies": {
"prosemirror-model": "^1.0.0",
"prosemirror-transform": "^1.0.0",
@@ -14327,7 +14325,6 @@
"resolved": "https://registry.npmjs.org/prosemirror-view/-/prosemirror-view-1.41.5.tgz",
"integrity": "sha512-UDQbIPnDrjE8tqUBbPmCOZgtd75htE6W3r0JCmY9bL6W1iemDM37MZEKC49d+tdQ0v/CKx4gjxLoLsfkD2NiZA==",
"license": "MIT",
- "peer": true,
"dependencies": {
"prosemirror-model": "^1.20.0",
"prosemirror-state": "^1.0.0",