@loftyshaky/shared-app 1.0.2 → 1.2.0

package/js/package/plugins/rollup-plugin-copy.js

@@ -1,169 +1,169 @@
-const path = require('path');
-const util = require('util');
-const fs = require('fs-extra');
-const isObject = require('is-plain-object');
-const globby = require('globby');
-const { bold, green, yellow } = require('colorette');
-
-function stringify(value) {
-    return util.inspect(value, { breakLength: Infinity });
-}
-
-async function isFile(filePath) {
-    const fileStats = await fs.stat(filePath);
-
-    return fileStats.isFile();
-}
-
-function renameTarget(target, rename) {
-    const parsedPath = path.parse(target);
-
-    return typeof rename === 'string'
-        ? rename
-        : rename(parsedPath.name, parsedPath.ext.replace('.', ''));
-}
-
-async function generateCopyTarget(src, dest, { flatten, rename, transform }) {
-    if (transform && !(await isFile(src))) {
-        throw new Error(`"transform" option works only on files: '${src}' must be a file`);
-    }
-
-    const { base, dir } = path.parse(src);
-    const destinationFolder =
-        flatten || (!flatten && !dir) ? dest : dir.replace(dir.split('/')[0], dest);
-
-    return {
-        src,
-        dest: path.join(destinationFolder, rename ? renameTarget(base, rename) : base),
-        ...(transform && { contents: await transform(await fs.readFile(src)) }),
-        renamed: rename,
-        transformed: transform,
-    };
-}
-
-module.exports = function copy(options = {}) {
-    const {
-        copyOnce = false,
-        flatten = true,
-        hook = 'buildEnd',
-        targets = [],
-        verbose = false,
-        callback_start,
-        callback_end,
-        ...restPluginOptions
-    } = options;
-
-    let copied = false;
-
-    return {
-        name: 'copy',
-        [hook]: async () => {
-            if (callback_start != null) {
-                await callback_start();
-            }
-
-            if (copyOnce && copied) {
-                return;
-            }
-
-            const copyTargets = [];
-
-            if (Array.isArray(targets) && targets.length) {
-                for (const target of targets) {
-                    if (!isObject(target)) {
-                        throw new Error(`${stringify(target)} target must be an object`);
-                    }
-
-                    const { dest, rename, src, transform, ...restTargetOptions } = target;
-
-                    if (!src || !dest) {
-                        throw new Error(
-                            `${stringify(target)} target must have "src" and "dest" properties`,
-                        );
-                    }
-
-                    if (rename && typeof rename !== 'string' && typeof rename !== 'function') {
-                        throw new Error(
-                            `${stringify(
-                                target,
-                            )} target's "rename" property must be a string or a function`,
-                        );
-                    }
-
-                    const matchedPaths = await globby(src, {
-                        expandDirectories: false,
-                        onlyFiles: false,
-                    });
-
-                    if (matchedPaths.length) {
-                        for (const matchedPath of matchedPaths) {
-                            const generatedCopyTargets = Array.isArray(dest)
-                                ? await Promise.all(
-                                      dest.map((destination) =>
-                                          generateCopyTarget(matchedPath, destination, {
-                                              flatten,
-                                              rename,
-                                              transform,
-                                          }),
-                                      ),
-                                  )
-                                : [
-                                      await generateCopyTarget(matchedPath, dest, {
-                                          flatten,
-                                          rename,
-                                          transform,
-                                      }),
-                                  ];
-
-                            copyTargets.push(...generatedCopyTargets);
-                        }
-                    }
-                }
-            }
-
-            if (copyTargets.length) {
-                setTimeout(async () => {
-                    if (verbose) {
-                        console.log(green('copied:'));
-                    }
-
-                    for (const copyTarget of copyTargets) {
-                        const { contents, dest, src, transformed } = copyTarget;
-
-                        if (transformed) {
-                            await fs.outputFile(dest, contents, restPluginOptions);
-                        } else {
-                            try {
-                                await fs.copy(src, dest, restPluginOptions);
-                            } catch (error_obj)  {}
-                        }
-
-                        if (verbose) {
-                            let message = green(`  ${bold(src)} → ${bold(dest)}`);
-                            const flags = Object.entries(copyTarget)
-                                .filter(
-                                    ([key, value]) =>
-                                        ['renamed', 'transformed'].includes(key) && value,
-                                )
-                                .map(([key]) => key.charAt(0).toUpperCase());
-
-                            if (flags.length) {
-                                message = `${message} ${yellow(`[${flags.join(', ')}]`)}`;
-                            }
-
-                            console.log(message);
-                        }
-                    }
-
-                    if (callback_end != null) {
-                        callback_end();
-                    }
-                }, 0);
-            } else if (verbose) {
-                console.log(yellow('no items to copy'));
-            }
-
-            copied = true;
-        },
-    };
-};
+const path = require('path');
+const util = require('util');
+const fs = require('fs-extra');
+const isObject = require('is-plain-object');
+const globby = require('globby');
+const { bold, green, yellow } = require('colorette');
+
+function stringify(value) {
+    return util.inspect(value, { breakLength: Infinity });
+}
+
+async function isFile(filePath) {
+    const fileStats = await fs.stat(filePath);
+
+    return fileStats.isFile();
+}
+
+function renameTarget(target, rename) {
+    const parsedPath = path.parse(target);
+
+    return typeof rename === 'string'
+        ? rename
+        : rename(parsedPath.name, parsedPath.ext.replace('.', ''));
+}
+
+async function generateCopyTarget(src, dest, { flatten, rename, transform }) {
+    if (transform && !(await isFile(src))) {
+        throw new Error(`"transform" option works only on files: '${src}' must be a file`);
+    }
+
+    const { base, dir } = path.parse(src);
+    const destinationFolder =
+        flatten || (!flatten && !dir) ? dest : dir.replace(dir.split('/')[0], dest);
+
+    return {
+        src,
+        dest: path.join(destinationFolder, rename ? renameTarget(base, rename) : base),
+        ...(transform && { contents: await transform(await fs.readFile(src)) }),
+        renamed: rename,
+        transformed: transform,
+    };
+}
+
+module.exports = function copy(options = {}) {
+    const {
+        copyOnce = false,
+        flatten = true,
+        hook = 'buildEnd',
+        targets = [],
+        verbose = false,
+        callback_start,
+        callback_end,
+        ...restPluginOptions
+    } = options;
+
+    let copied = false;
+
+    return {
+        name: 'copy',
+        [hook]: async () => {
+            if (callback_start != null) {
+                await callback_start();
+            }
+
+            if (copyOnce && copied) {
+                return;
+            }
+
+            const copyTargets = [];
+
+            if (Array.isArray(targets) && targets.length) {
+                for (const target of targets) {
+                    if (!isObject(target)) {
+                        throw new Error(`${stringify(target)} target must be an object`);
+                    }
+
+                    const { dest, rename, src, transform, ...restTargetOptions } = target;
+
+                    if (!src || !dest) {
+                        throw new Error(
+                            `${stringify(target)} target must have "src" and "dest" properties`,
+                        );
+                    }
+
+                    if (rename && typeof rename !== 'string' && typeof rename !== 'function') {
+                        throw new Error(
+                            `${stringify(
+                                target,
+                            )} target's "rename" property must be a string or a function`,
+                        );
+                    }
+
+                    const matchedPaths = await globby(src, {
+                        expandDirectories: false,
+                        onlyFiles: false,
+                    });
+
+                    if (matchedPaths.length) {
+                        for (const matchedPath of matchedPaths) {
+                            const generatedCopyTargets = Array.isArray(dest)
+                                ? await Promise.all(
+                                      dest.map((destination) =>
+                                          generateCopyTarget(matchedPath, destination, {
+                                              flatten,
+                                              rename,
+                                              transform,
+                                          }),
+                                      ),
+                                  )
+                                : [
+                                      await generateCopyTarget(matchedPath, dest, {
+                                          flatten,
+                                          rename,
+                                          transform,
+                                      }),
+                                  ];
+
+                            copyTargets.push(...generatedCopyTargets);
+                        }
+                    }
+                }
+            }
+
+            if (copyTargets.length) {
+                setTimeout(async () => {
+                    if (verbose) {
+                        console.log(green('copied:'));
+                    }
+
+                    for (const copyTarget of copyTargets) {
+                        const { contents, dest, src, transformed } = copyTarget;
+
+                        if (transformed) {
+                            await fs.outputFile(dest, contents, restPluginOptions);
+                        } else {
+                            try {
+                                await fs.copy(src, dest, restPluginOptions);
+                            } catch (error_obj) {}
+                        }
+
+                        if (verbose) {
+                            let message = green(`  ${bold(src)} → ${bold(dest)}`);
+                            const flags = Object.entries(copyTarget)
+                                .filter(
+                                    ([key, value]) =>
+                                        ['renamed', 'transformed'].includes(key) && value,
+                                )
+                                .map(([key]) => key.charAt(0).toUpperCase());
+
+                            if (flags.length) {
+                                message = `${message} ${yellow(`[${flags.join(', ')}]`)}`;
+                            }
+
+                            console.log(message);
+                        }
+                    }
+
+                    if (callback_end != null) {
+                        callback_end();
+                    }
+                }, 0);
+            } else if (verbose) {
+                console.log(yellow('no items to copy'));
+            }
+
+            copied = true;
+        },
+    };
+};

package/js/package/plugins/watcher.js

@@ -1,56 +1,56 @@
-const path = require('path');
-
-const appRoot = require('app-root-path');
-const recursiveReaddir = require('recursive-readdir');
-const _ = require('lodash');
-
-const { TaskScheduler } = require('../../task_scheduler');
-
-const task_scheduler = new TaskScheduler();
-
-const app_root = appRoot.path;
-
-let initial_run_completed = false;
-
-const generate_watch_files = async () => {
-    let watch_files = [];
-
-    const src_dir = path.join(app_root, 'src');
-
-    const dirs = [
-        path.join(app_root, 'js'),
-        path.join(src_dir, '_locales'),
-        path.join(src_dir, 'scss'),
-    ];
-
-    await Promise.all(
-        dirs.map(async (dir) => {
-            const files = await recursiveReaddir(dir);
-
-            watch_files = _.union(watch_files, files);
-        }),
-    );
-
-    return watch_files;
-};
-
-module.exports = function watcher({ mode }) {
-    return {
-        async buildStart() {
-            if (!initial_run_completed) {
-                await task_scheduler.unlock_dist({
-                    package_name: 'Shared',
-                    remove_dist: mode === 'production',
-                });
-
-                initial_run_completed = true;
-            }
-
-            const watch_files = await generate_watch_files();
-
-            watch_files.forEach((file) => {
-                this.addWatchFile(file);
-            });
-        },
-    };
-};
+const path = require('path');
+
+const appRoot = require('app-root-path');
+const recursiveReaddir = require('recursive-readdir');
+const _ = require('lodash');
+
+const { TaskScheduler } = require('../../task_scheduler');
+
+const task_scheduler = new TaskScheduler();
+
+const app_root = appRoot.path;
+
+let initial_run_completed = false;
+
+const generate_watch_files = async () => {
+    let watch_files = [];
+
+    const src_dir = path.join(app_root, 'src');
+
+    const dirs = [
+        path.join(app_root, 'js'),
+        path.join(src_dir, '_locales'),
+        path.join(src_dir, 'scss'),
+    ];
+
+    await Promise.all(
+        dirs.map(async (dir) => {
+            const files = await recursiveReaddir(dir);
+
+            watch_files = _.union(watch_files, files);
+        }),
+    );
+
+    return watch_files;
+};
+
+module.exports = function watcher({ mode }) {
+    return {
+        async buildStart() {
+            if (!initial_run_completed) {
+                await task_scheduler.unlock_dist({
+                    package_name: 'Shared',
+                    remove_dist: mode === 'production',
+                });
+
+                initial_run_completed = true;
+            }
+
+            const watch_files = await generate_watch_files();
+
+            watch_files.forEach((file) => {
+                this.addWatchFile(file);
+            });
+        },
+    };
+};

package/js/package/terser.js

@@ -1,18 +1,18 @@
-class Terser {
-    config = {
-        output: {
-            comments(node, comment) {
-                const text = comment.value;
-                const { type } = comment;
-                if (type === 'comment2') {
-                    return /@preserve|@license|@cc_on/i.test(text);
-                }
-
-                return undefined;
-            },
-        },
-        mangle: false,
-    };
-}
-
-module.exports = { Terser };
+class Terser {
+    config = {
+        output: {
+            comments(node, comment) {
+                const text = comment.value;
+                const { type } = comment;
+                if (type === 'comment2') {
+                    return /@preserve|@license|@cc_on/i.test(text);
+                }
+
+                return undefined;
+            },
+        },
+        mangle: false,
+    };
+}
+
+module.exports = { Terser };

package/js/task_scheduler.js

@@ -1,39 +1,39 @@
-const path = require('path');
-const fs = require('fs-extra');
-const childProcess = require('child_process');
-
-const { ProjectName } = require('./project_name');
-
-const project_name = new ProjectName();
-
-class TaskScheduler {
-    unlock_dist = async ({ package_name, remove_dist }) => {
-        const is_windows = process.platform === 'win32';
-
-        if (
-            (is_windows &&
-                fs.existsSync(path.join('C:', 'Program Files', 'LockHunter', 'LockHunter.exe'))) ||
-            !is_windows
-        ) {
-            if (is_windows) {
-                childProcess.execSync(`SCHTASKS.EXE /RUN /TN "Unlock ${package_name} dist dir"`);
-            }
-
-            if (remove_dist) {
-                // eslint-disable-next-line global-require
-                const { projects_path } = require('./projects_path');
-
-                fs.removeSync(
-                    path.join(
-                        projects_path.q,
-                        package_name,
-                        project_name.transform({ project: package_name }),
-                        'dist',
-                    ),
-                );
-            }
-        }
-    };
-}
-
-module.exports = { TaskScheduler };
+const path = require('path');
+const fs = require('fs-extra');
+const childProcess = require('child_process');
+
+const { ProjectName } = require('./project_name');
+
+const project_name = new ProjectName();
+
+class TaskScheduler {
+    unlock_dist = async ({ package_name, remove_dist }) => {
+        const is_windows = process.platform === 'win32';
+
+        if (
+            (is_windows &&
+                fs.existsSync(path.join('C:', 'Program Files', 'LockHunter', 'LockHunter.exe'))) ||
+            !is_windows
+        ) {
+            if (is_windows) {
+                childProcess.execSync(`SCHTASKS.EXE /RUN /TN "Unlock ${package_name} dist dir"`);
+            }
+
+            if (remove_dist) {
+                // eslint-disable-next-line global-require
+                const { projects_path } = require('./projects_path');
+
+                fs.removeSync(
+                    path.join(
+                        projects_path.q,
+                        package_name,
+                        project_name.transform({ project: package_name }),
+                        'dist',
+                    ),
+                );
+            }
+        }
+    };
+}
+
+module.exports = { TaskScheduler };

package/js/tsc_alias.js

@@ -0,0 +1,19 @@
+const child_process = require('child_process');
+
+class TscAlias {
+    transform_aliases_to_relative_paths = () => ({
+        name: 'tsAlias',
+        writeBundle: () =>
+            new Promise((resolve, reject) => {
+                child_process.exec('tsc-alias', function callback(error, stdout, stderr) {
+                    if (stderr || error) {
+                        reject(stderr || error);
+                    } else {
+                        resolve(stdout);
+                    }
+                });
+            }),
+    });
+}
+
+module.exports = { TscAlias };