@newlogic-digital/core 0.9.13 → 1.0.0-beta.2

package/modules/Emails.js

@@ -1,110 +0,0 @@
-import lazypipe from "lazypipe";
-import gulpif from "gulp-if";
-import postcss from "gulp-postcss";
-import autoprefixer from "autoprefixer";
-import twig from "../packages/gulp-twig2html/index.js";
-import gulp from "gulp";
-import fs from "fs";
-import {Config, Modules, Templates, Utils, root} from "./Core.js";
-
-export class Emails {
-    async build() {
-        const inlineCss = (await import('gulp-inline-css')).default;
-        const replace = (await import('gulp-replace')).default;
-        const rename = (await import('gulp-rename')).default;
-        const postcssCustomProperties = (await import('postcss-custom-properties')).default;
-
-        const inlineCssOpt = {
-            applyStyleTags: true,
-            applyLinkTags: true,
-            removeStyleTags: Config.emails.inlineOnly
-        }
-
-        const buildCss = lazypipe().pipe(() => gulpif("*.css", postcss(new Utils().postcssPluginsEmails(Config.emails.postcss, [postcssCustomProperties({
-            preserve: false
-        }), autoprefixer])))
-        ).pipe(() => gulpif("*.less", Modules.less.module()))
-
-        return new Promise(resolve => {
-            let twigFiles = "*.twig";
-            let hbsFiles = "*.hbs";
-
-            if (Config.emails.format === "twig") {
-                twigFiles = twigFiles.replace("twig", "{twig,latte,tpl}")
-            } else if (Config.emails.format === "hbs") {
-                hbsFiles = hbsFiles.replace("hbs", "{hbs,latte,tpl}")
-            }
-
-            const build = lazypipe().pipe(() => gulpif(twigFiles, twig({
-                functions: new Templates().functions,
-                filters: new Templates().filters,
-                extensions: new Templates().tags
-            })))
-                .pipe(() => gulpif(hbsFiles, Modules.hbs.module(`${root + Config.paths.input.emails}/**/*.hbs`, Modules.hbs.helpers(Object.assign(new Templates().filters, new Templates().functions)))))
-                .pipe(() => gulpif("*.{hbs,twig}", rename({ extname: ".html" })))
-
-            gulp.series(
-                function styles() {
-                    return gulp.src(root + Config.paths.input.emails + '/*.{css,less}')
-                        .pipe(buildCss())
-                        .pipe(gulp.dest(root + Config.paths.temp + "/emails"));
-                },
-                function templates() {
-                    return gulp.src(root + Config.paths.input.emails + '/*.{hbs,twig,tpl,latte}')
-                        .pipe(build())
-                        .pipe(replace('<table', '<table border="0" cellpadding="0" cellspacing="0"'))
-                        .pipe(inlineCss(inlineCssOpt))
-                        .pipe(gulpif(Config.emails.removeClasses,replace(/class="([A-Za-z0-9 _]*)"/g, '')))
-                        .pipe(gulpif(("*.html"), gulp.dest(root + Config.paths.output.emails)))
-                        .pipe(gulpif("*.{latte,tpl}", gulp.dest(root + Config.paths.output.emailsWww)))
-                }
-            )(resolve)
-        })
-    }
-    zip() {
-        return new Promise(async (resolve) => {
-            const AdmZip = (await import('adm-zip')).default;
-
-            let files = fs.readdirSync(root + Config.paths.output.emails);
-            let prefixes = Config.emails.zipPrefix;
-
-            function zipFile(file, imageSubfolder) {
-                let zip = new AdmZip();
-
-                if (typeof imageSubfolder !== "undefined" && fs.existsSync(`${root + Config.paths.output.emailsImg}/${imageSubfolder}`)) {
-                    if (imageSubfolder.endsWith("-")) {
-                        imageSubfolder.slice(0, imageSubfolder.length - 1)
-                    }
-                    imageSubfolder = "/" + imageSubfolder
-                } else {
-                    imageSubfolder = ""
-                }
-
-                zip.addFile("index.html", fs.readFileSync(`${root + Config.paths.output.emails}/${file}`));
-                zip.toBuffer();
-
-                if (fs.existsSync(`${root + Config.paths.output.emailsImg}${imageSubfolder}`)) {
-                    zip.addLocalFolder(`${root + Config.paths.output.emailsImg}${imageSubfolder}`, `images${imageSubfolder}`);
-                }
-
-                zip.writeZip(`${root + Config.paths.output.emails}/${file.replace(".html", ".zip")}`);
-            }
-
-            files.forEach((file) => {
-                if (file.endsWith(".html")) {
-                    if (Config.emails.zipPrefix) {
-                        prefixes.filter((prefix) => {
-                            if (file.startsWith(prefix)) {
-                                zipFile(file, prefix);
-                            }
-                        });
-                    } else {
-                        zipFile(file);
-                    }
-                }
-            });
-
-            resolve();
-        })
-    }
-}

package/modules/Icons.js

@@ -1,140 +0,0 @@
-import path from "path";
-import fs from "fs";
-import lazypipe from "lazypipe";
-import gulpif from "gulp-if";
-import postcss from "gulp-postcss";
-import autoprefixer from "autoprefixer";
-import gulp from "gulp";
-import plumber from "gulp-plumber";
-import {Config, Functions, Modules, Utils, root} from "./Core.js";
-
-export class Icons {
-    async fetch() {
-        const http = (await import("https")).default;
-
-        return new Promise((resolve, reject) => {
-            if (Config.icons.local === true || Config.local === true) {
-                resolve();
-            }
-
-            if (typeof Config.icons.name === "undefined" || Config.icons.name === "") {
-                Config.icons.name = path.basename(path.resolve(root));
-            }
-
-            let files = [
-                `https://i.icomoon.io/public/${Config.icons.id}/${Config.icons.name}/variables.less`,
-                `https://i.icomoon.io/public/${Config.icons.id}/${Config.icons.name}/style.less`,
-                `https://i.icomoon.io/public/${Config.icons.id}/${Config.icons.name}/selection.json`
-            ]
-
-            if (!fs.existsSync(root + Config.paths.input.icons)) {
-                fs.mkdirSync(root + Config.paths.input.icons);
-            }
-
-            let variables = {};
-
-            Promise.allSettled(files.map(async (url) => {
-                let name = url.substring(url.indexOf(Config.icons.name) + Config.icons.name.length, url.length).replace("/","");
-
-                return new Promise((resolveFile, rejectFile) => {
-                    http.get(url, response => {
-                        if (response.statusCode === 200) {
-                            if ((name === "variables.less" || name === "style.less") && Config.icons.format !== "less") {
-                                response.setEncoding('utf8');
-                                let body = "";
-                                response.on('data', chunk => body += chunk);
-                                response.on('end', () => {
-
-                                    if (name === "variables.less") {
-                                        body.match(/@(.+);/gm).filter(variable => {
-                                            let match = variable.match(/@(.+): "(.+)";/);
-
-                                            variables[match[1]] = match[2]
-                                        })
-
-                                        body = `:root {${Object.keys(variables).map(variable => `--${variable}: "${variables[variable]}";\n`).join("")}}`;
-
-                                        fs.writeFile(`${root + Config.paths.input.icons}/variables.css`, body, resolveFile);
-                                    }
-
-                                    if (name === "style.less") {
-                                        body = body.replace(`@import "variables";`, `@import "variables.css";`)
-
-                                        fs.writeFile(`${root + Config.paths.input.icons}/iconfont.css`, body, resolveFile)
-                                    }
-                                });
-
-                            } else if (name === "style.less" && Config.icons.format === "less") {
-                                response.pipe(fs.createWriteStream(`${root + Config.paths.input.icons}/iconfont.less`)).on("close", resolveFile);
-                            } else {
-                                response.pipe(fs.createWriteStream(`${root + Config.paths.input.icons}/${name}`)).on("close", resolveFile);
-                            }
-                        } else {
-                            console.error("\x1b[31m", `Error: ${url} returns ${response.statusCode}`, "\x1b[0m");
-                            rejectFile()
-                        }
-                    });
-                })
-            })).then(result => {
-                if (result[0].status !== "rejected") {
-                    if (fs.existsSync(`${root + Config.paths.input.icons}/iconfont.css`)) {
-                        let file = fs.readFileSync(`${root + Config.paths.input.icons}/iconfont.css`).toString();
-
-                        Object.keys(variables).map(variable => {
-                            file = file.replace(new RegExp(`@{${variable}}`, 'g'), `${variables[variable]}`)
-                            file = file.replace(`@${variable}`, `var(--${variable})`)
-                        })
-
-                        file = file.replace(new RegExp('-"]', 'g'), '-"]:before')
-                        file = file.replace('!important;', ';')
-
-                        fs.writeFileSync(`${root + Config.paths.input.icons}/iconfont.css`, file);
-                    }
-
-                    if (fs.existsSync(`${root + Config.paths.input.icons}/iconfont.less`)) {
-                        let file = fs.readFileSync(`${root + Config.paths.input.icons}/iconfont.less`).toString();
-
-                        file = file.replace(new RegExp('-"]', 'g'), '-"]:before')
-                        file = file.replace('!important;', ';')
-
-                        fs.writeFileSync(`${root + Config.paths.input.icons}/iconfont.less`, file);
-                    }
-
-                    console.log("\x1b[34m", `Icomoon demo - https://i.icomoon.io/public/reference.html#/${Config.icons.id}/${Config.icons.name}/`, "\x1b[0m");
-                    resolve();
-                } else {
-                    console.error("\x1b[31m", `Is project added in icomoon.app, has the correct name or is quick usage enabled?`, "\x1b[0m");
-                    reject();
-                }
-            })
-        })
-    }
-    async build() {
-        const replace = (await import('gulp-replace')).default;
-        const cleanCSS = (await import("../packages/gulp-clean-css/index.js")).default;
-        const rename = (await import('gulp-rename')).default;
-        const revision = (await import("gulp-rev")).default;
-
-        const rev = lazypipe().pipe(revision).pipe(Functions.revUpdate, true, "icons");
-
-        const clean = lazypipe().pipe(cleanCSS);
-
-        const build = lazypipe().pipe(() => gulpif("*.css", postcss(new Utils().postcssPlugins(Config.icons.postcss, [autoprefixer])))
-        ).pipe(() => gulpif("*.less", Modules.less.module()))
-
-        return gulp.src(`${root + Config.paths.input.icons}/iconfont.{css,less}`)
-            .pipe(plumber(Functions.plumber))
-            .pipe(rename(function(path){
-                path.basename = Config.icons.filename;
-            }))
-            .pipe(build())
-            .pipe(gulpif(Config.icons.revision, rev()))
-            .pipe(gulpif(Config.icons.optimizations, clean()))
-            .pipe(gulp.dest(root + Config.paths.output.icons))
-            .pipe(revision.manifest(root + Config.paths.output.icons + "/rev-manifest.json",{
-                merge: true,
-                base: root + Config.paths.output.icons
-            }))
-            .pipe(gulp.dest(root + Config.paths.output.icons));
-    }
-}

package/modules/Scripts.js

@@ -1,321 +0,0 @@
-import fs from "fs";
-import fse from "fs-extra";
-import lodash from "lodash";
-import {Config, Functions, root} from "./Core.js";
-
-export class Scripts {
-    importResolution() {
-        return new Promise(resolve => {
-            Config.scripts.importResolution.directories.map(directory => {
-                if (!fs.existsSync(`${root + Config.paths.input.scripts}/${directory}`)) {
-                    console.log("\x1b[31m", `importResolution - ${Config.paths.input.scripts}/${directory} doesn't exists`, "\x1b[0m");
-                    return false;
-                }
-
-                let items = fs.readdirSync(`${root + Config.paths.input.scripts}/${directory}`);
-
-                function findPaths(items, directory) {
-                    let imports = "";
-
-                    items.map(item => {
-                        let path = `${directory}/${item}`;
-
-                        if (fs.statSync(path).isFile()) {
-                            if (path.includes(".js") && !path.includes(Config.scripts.importResolution.filename)) {
-                                if (fs.readFileSync(path).toString().includes("export default")) {
-                                    imports = imports + `export { default as ${item.replace(".js","")} } from './${item}'\r\n`
-                                } else {
-                                    imports = imports + `import './${item}'\r\n`
-                                }
-                            }
-                        } else {
-                            if (Config.scripts.importResolution.subDir) {
-                                imports = imports + `import '${item}/${Config.scripts.importResolution.filename}'\r\n`
-                            }
-                            findPaths(fs.readdirSync(path), path);
-                        }
-                    });
-
-                    let path = `${directory}/${Config.scripts.importResolution.filename}`;
-
-                    if (fs.existsSync(path) && fs.readFileSync(path).toString() !== imports || !fs.existsSync(path)) {
-                        fs.writeFileSync(path, imports);
-                    }
-                }
-
-                findPaths(items, `${root + Config.paths.input.scripts}/${directory}`);
-            });
-
-            resolve();
-        });
-    }
-    async concat() {
-        const gulp = (await import("gulp")).default;
-        const plumber = (await import("gulp-plumber")).default;
-        const lazypipe = (await import("lazypipe")).default;
-        const gulpif = (await import("gulp-if")).default;
-        const through = (await import("through2")).default;
-        const revision = (await import("gulp-rev")).default;
-        const revRewrite = (await import("gulp-rev-rewrite")).default;
-        const terser = (await import("terser"));
-
-        function minify() {
-            return through.obj((file, enc, cb) => {
-                if (file.isNull()) {
-                    cb(null, file);
-                }
-                if (file.isBuffer()) {
-                    terser.minify(file.contents.toString()).then(function (result) {
-                        file.contents = Buffer.from(result.code);
-                        cb(null, file);
-                    });
-                }
-            });
-        }
-
-        const rev = lazypipe().pipe(revision).pipe(Functions.revUpdate, true, "scripts")
-            .pipe(revRewrite, {manifest: fs.existsSync(`${root + Config.paths.output.assets}/rev-manifest.json`) ? fs.readFileSync(`${root + Config.paths.output.assets}/rev-manifest.json`) : ""});
-
-        return new Promise(resolve => {
-            gulp.src(Config.scripts.concat)
-                .pipe(plumber(Functions.plumber))
-                .pipe(Functions.module("gulp-js-import-file", {
-                    hideConsole: true,
-                    importStack: false,
-                    es6import: true
-                }))
-                .pipe(Functions.revRewriteOutput())
-                .pipe(gulpif(Config.scripts.legacy, Functions.module("gulp-babel")))
-                .pipe(gulpif(Config.scripts.optimizations, minify()))
-                .pipe(gulpif(Config.scripts.revision, rev()))
-                .pipe(gulp.dest(root + Config.paths.output.scripts))
-                .pipe(revision.manifest(root + Config.paths.output.scripts + "/rev-manifest.json",{
-                    merge: true,
-                    base: root + Config.paths.output.scripts
-                }))
-                .pipe(gulp.dest(root + Config.paths.output.scripts))
-                .on('error', Functions.plumber.errorHandler)
-                .on('end', resolve);
-        })
-    }
-    async build() {
-        const {rollup} = await import('rollup');
-        const {nodeResolve} = await import('@rollup/plugin-node-resolve');
-        const commonjs = (await import('@rollup/plugin-commonjs')).default;
-        const {terser} = await import('rollup-plugin-terser');
-        const {rollupImportMapPlugin} = (await import('rollup-plugin-import-map'));
-        const replace = (await import('@rollup/plugin-replace')).default;
-
-        return new Promise(resolve => {
-            fse.removeSync(root + Config.paths.output.scripts);
-
-            const hashManifest = function(opts = {}) {
-                const defaults = {
-                    path: root + Config.paths.output.scripts
-                };
-
-                opts = Object.assign({}, defaults, opts);
-                let inputs;
-
-                return {
-                    options({ input }) {
-                        inputs = input;
-                        if (typeof inputs === "string") {
-                            inputs = [inputs];
-                        }
-                        if (typeof inputs === "object") {
-                            inputs = Object.values(inputs);
-                        }
-                    },
-                    generateBundle(_outputOptions, bundle) {
-                        let map = {};
-                        return Promise.all(inputs.map(id => this.resolve(id))).then(
-                            resolvedInputs => {
-                                for (const key of Object.keys(bundle)) {
-                                    const idx = resolvedInputs.findIndex(
-                                        input => input.id in (bundle[key].modules || {})
-                                    );
-                                    if (idx !== -1) {
-                                        const name = inputs[idx].split("/")[inputs[idx].split("/").length - 1];
-                                        map[name] = bundle[key].fileName;
-                                    }
-                                }
-
-                                if (fs.existsSync(opts.path + "/rev-manifest.json")) {
-                                    map = Object.assign(JSON.parse(fs.readFileSync(opts.path + "/rev-manifest.json").toString()), map);
-                                }
-
-                                fs.writeFileSync(opts.path + "/rev-manifest.json", JSON.stringify(map, null, "  "));
-                            }
-                        );
-                    }
-                };
-            }
-
-            let assetsManifest = fs.existsSync(`${root + Config.paths.output.assets}/rev-manifest.json`) ? JSON.parse(fs.readFileSync(`${root + Config.paths.output.assets}/rev-manifest.json`).toString()) : {};
-            let importMapFile = fs.existsSync(`${root + Config.paths.output.root}/importmap.json`) ? JSON.parse(fs.readFileSync(`${root + Config.paths.output.root}/importmap.json`).toString()) : {};
-            let files = fs.readdirSync(root + Config.paths.input.scripts);
-
-            if (!fs.existsSync(root + Config.paths.output.scripts)){
-                fs.mkdirSync(root + Config.paths.output.scripts);
-            }
-
-            Config.scripts.concat.map(file => lodash.pull(files, file.substr(file.lastIndexOf("/") + 1, file.length)))
-
-            Promise.all(files.map(async file => {
-                if (!fs.statSync(`${root + Config.paths.input.scripts}/${file}`).isDirectory()) {
-                    await (async() => {
-
-                        const inputOptions = {
-                            context: 'window',
-                            preserveEntrySignatures: true,
-                            plugins: [
-                                (Config.serve.mode === "" || Config.paths.output.rewrite) && replace({
-                                    preventAssignment: true,
-                                    values: {
-                                        '/* @vite-ignore */': ''
-                                    },
-                                    delimiters: ['', '']
-                                }),
-                                (Config.scripts.importMap.build && typeof importMapFile["imports"] !== "undefined") && rollupImportMapPlugin(importMapFile),
-                                !Config.scripts.importMap.build && nodeResolve({
-                                    browser: true
-                                }),
-                                !Config.scripts.importMap.build && commonjs(),
-                                replace({
-                                    preventAssignment: true,
-                                    values: Object.assign({
-                                        'process.env.NODE_ENV': JSON.stringify('production'),
-                                        [Config.paths.input.assets]: `${Config.paths.output.assets.replace(Config.paths.output.root + "/", Config.paths.base.length > 0 ? Config.paths.base + "/" : "")}`
-                                    }, assetsManifest)
-                                }),
-                                Config.scripts.optimizations && terser(),
-                                Config.scripts.revision && hashManifest()
-                            ]
-                        };
-
-                        const outputOptions = {
-                            dir: root + Config.paths.output.scripts,
-                            format: 'es',
-                            sourcemap: false,
-                            compact: true,
-                            entryFileNames: `[name]${Config.scripts.revision ? ".[hash]" : ""}.js`,
-                            chunkFileNames: '[name].[hash].js'
-                        };
-
-                        const bundle = await rollup(Object.assign({input: root + Config.paths.input.scripts + '/' + file}, inputOptions));
-
-                        await bundle.write(outputOptions);
-
-                        await bundle.close();
-                    })();
-
-                    Config.scripts.legacy && await (async() => {
-
-                        const {getBabelOutputPlugin} = await import('@rollup/plugin-babel');
-
-                        const inputOptions = {
-                            context: 'window',
-                            preserveEntrySignatures: false,
-                            plugins: [
-                                (Config.serve.mode === "" || Config.paths.output.rewrite) && replace({
-                                    preventAssignment: true,
-                                    values: {
-                                        '/* @vite-ignore */': ''
-                                    },
-                                    delimiters: ['', '']
-                                }),
-                                nodeResolve({
-                                    browser: true
-                                }),
-                                commonjs(),
-                                replace({
-                                    preventAssignment: true,
-                                    values: Object.assign({
-                                        'process.env.NODE_ENV': JSON.stringify('production')
-                                    }, assetsManifest)
-                                }),
-                                Config.scripts.revision && hashManifest({path: root + Config.paths.output.scripts + "/es5/"})
-                            ]
-                        };
-
-                        const outputOptions = {
-                            dir: root + Config.paths.output.scripts + "/es5/",
-                            format: 'es',
-                            sourcemap: false,
-                            compact: true,
-                            entryFileNames: `[name]${Config.scripts.revision ? ".[hash]" : ""}.js`,
-                            chunkFileNames: '[name].[hash].js',
-                            plugins: [
-                                getBabelOutputPlugin({
-                                    presets: [['@babel/env', { modules: 'amd',
-                                        targets: {
-                                            "ie": "11"
-                                        },
-                                        useBuiltIns: 'entry',
-                                        corejs: "3.8"
-                                    }]]
-                                }),
-                            ]
-                        };
-
-                        if (!fs.existsSync(root + Config.paths.output.scripts + "/es5")){
-                            fs.mkdirSync(root + Config.paths.output.scripts + "/es5");
-                        }
-
-                        const bundle = await rollup(Object.assign({input: root + Config.paths.input.scripts + `/${file}`}, inputOptions));
-
-                        await bundle.write(outputOptions);
-
-                        await bundle.close();
-                    })();
-                }
-            })).then(async () => {
-                Config.scripts.legacy && await (async() => {
-                    let polyfills = "";
-
-                    if (typeof Config.scripts.polyfillUrls !== "undefined") {
-                        Config.scripts.polyfillUrls.map((script) => {
-                            polyfills = polyfills.concat(`document.write('<script src="${script}"><\\/script>');`)
-                        });
-                    }
-
-                    fs.writeFileSync(root + Config.paths.temp + `/polyfills.js`, Functions.stripIndent(`
-                        document.write('<script src="https://polyfill.io/v3/polyfill.min.js?features=${Config.scripts.polyfillFeatures}"><\\/script>');
-                        document.write('<script src="https://cdn.jsdelivr.net/npm/whatwg-fetch@3.5.0/dist/fetch.umd.min.js"><\\/script>');
-                        document.write('<script src="https://cdn.jsdelivr.net/npm/regenerator-runtime@0.13.7/runtime.min.js"><\\/script>');
-                        document.write('<script src="https://cdn.jsdelivr.net/npm/requirejs@2.3.6/require.min.js"><\\/script>');
-                        ${polyfills}
-                    `).replace(/^\s*\n/g, ""));
-
-                    const inputOptions = {
-                        context: 'window',
-                        preserveEntrySignatures: false,
-                        plugins: [
-                            Config.scripts.revision && hashManifest({path: root + Config.paths.output.scripts + "/es5/"})
-                        ]
-                    };
-
-                    const outputOptions = {
-                        dir: root + Config.paths.output.scripts + "/es5/",
-                        format: 'es',
-                        sourcemap: false,
-                        compact: true,
-                        entryFileNames: `[name]${Config.scripts.revision ? ".[hash]" : ""}.js`
-                    };
-                    const bundle = await rollup(Object.assign({input: root + Config.paths.temp + `/polyfills.js`}, inputOptions));
-
-                    await bundle.write(outputOptions);
-
-                    await bundle.close();
-                })();
-
-                if (Config.scripts.concat.length > 0) {
-                    await new Scripts().concat();
-                }
-
-                resolve();
-            });
-        });
-    }
-}