lincd-cli 0.2.32 → 0.2.36

package/lib/config-webpack.js

@@ -1,112 +1,53 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateWebpackConfig = void 0;
-var declaration_plugin_1 = __importDefault(require("./plugins/declaration-plugin"));
-var externalise_modules_1 = __importDefault(require("./plugins/externalise-modules"));
-var watch_run_1 = __importDefault(require("./plugins/watch-run"));
-var utils_1 = require("./utils");
-var colors = require("colors");
+const declaration_plugin_1 = __importDefault(require("./plugins/declaration-plugin"));
+const externalise_modules_1 = __importDefault(require("./plugins/externalise-modules"));
+const watch_run_1 = __importDefault(require("./plugins/watch-run"));
+const utils_1 = require("./utils");
+const colors = require("colors");
 // console.log('Webpack '+require('webpack/package.json').version);
 // console.log('ts-loader '+require('ts-loader/package.json').version);
-var fs = require('fs');
-var MiniCssExtractPlugin = require('mini-css-extract-plugin');
-var chalk = require('chalk');
-var webpack = require('webpack');
-var path = require('path');
+const fs = require('fs');
+const MiniCssExtractPlugin = require('mini-css-extract-plugin');
+const chalk = require('chalk');
+const webpack = require('webpack');
+const path = require('path');
 // const WebpackLicencePlugin = require('webpack-license-plugin');
 // const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
-var BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
-var TerserPlugin = require('terser-webpack-plugin');
-var exec = require('child_process').exec;
-var CopyPlugin = require('copy-webpack-plugin');
-var tailwindPlugin = require('tailwindcss/plugin');
-var NODE_ENV = process.env.NODE_ENV;
-var nodeProduction = NODE_ENV == 'production';
+const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
+const TerserPlugin = require('terser-webpack-plugin');
+const exec = require('child_process').exec;
+const CopyPlugin = require('copy-webpack-plugin');
+const tailwindPlugin = require('tailwindcss/plugin');
+const NODE_ENV = process.env.NODE_ENV;
+const nodeProduction = NODE_ENV == 'production';
 // const libraryName = 'lincd';
 process.traceDeprecation = true;
 function getLincdPackagePaths(packages) {
-    var e_1, _a;
     if (!packages) {
-        var pkgJson = (0, utils_1.getPackageJSON)();
-        packages = __assign(__assign({}, pkgJson.dependencies), pkgJson.devDependencies);
+        let pkgJson = (0, utils_1.getPackageJSON)();
+        packages = Object.assign(Object.assign({}, pkgJson.dependencies), pkgJson.devDependencies);
     }
-    var lincdPackagePaths = [];
-    try {
-        for (var _b = __values(Object.keys(packages)), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var dependency = _c.value;
-            try {
-                var pkgJson = require(dependency + '/package.json');
-                if (pkgJson.lincd) {
-                    var pkgPath = require.resolve(dependency + '/package.json');
-                    lincdPackagePaths.push(pkgPath.substring(0, pkgPath.length - 13));
-                }
-            }
-            catch (err) {
-                // console.log("could not find "+dependency);
+    let lincdPackagePaths = [];
+    for (var dependency of Object.keys(packages)) {
+        try {
+            let pkgJson = require(dependency + '/package.json');
+            if (pkgJson.lincd) {
+                let pkgPath = require.resolve(dependency + '/package.json');
+                lincdPackagePaths.push(pkgPath.substring(0, pkgPath.length - 13));
             }
         }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+        catch (err) {
+            // console.log("could not find "+dependency);
         }
-        finally { if (e_1) throw e_1.error; }
     }
     return lincdPackagePaths;
 }
-function generateWebpackConfig(buildName, moduleName, config) {
-    if (config === void 0) { config = {}; }
+function generateWebpackConfig(buildName, moduleName, config = {}) {
     if (!config.externals)
         config.externals = {};
     if (!config.internals)
@@ -128,7 +69,7 @@ function generateWebpackConfig(buildName, moduleName, config) {
         (0, utils_1.warn)('Cannot find ' + configFile);
         process.exit();
     }
-    var tsConfig = JSON.parse(fs.readFileSync(configFile));
+    let tsConfig = JSON.parse(fs.readFileSync(configFile));
     var plugins = [
         // new webpack.DefinePlugin({
         //   'process.env.BROWSER': JSON.stringify(true),
@@ -138,7 +79,7 @@ function generateWebpackConfig(buildName, moduleName, config) {
         // new ExtractTextPlugin(config.cssFileName ? config.cssFileName : cleanModuleName + '.css'),
         new MiniCssExtractPlugin({
             // linkType: false,
-            filename: config.cssFileName ? config.cssFileName : cleanModuleName + '.css'
+            filename: config.cssFileName ? config.cssFileName : cleanModuleName + '.css',
         }),
         //currently not compatible with webpack 5
         // new WebpackLicencePlugin({
@@ -152,38 +93,37 @@ function generateWebpackConfig(buildName, moduleName, config) {
             patterns: [
                 {
                     from: 'src/**/*.scss',
-                    to: function (_a) {
-                        var context = _a.context, absoluteFilename = _a.absoluteFilename;
+                    to({ context, absoluteFilename }) {
                         // console.log(chalk.magenta(context),chalk.magenta(absoluteFilename),process.cwd());
                         //turn absolute path into the right lib path (lib is NOT in webpack output path, so need to use '../')
-                        var outputPath = absoluteFilename.replace(process.cwd(), '').replace('/src/', '../lib/');
+                        let outputPath = absoluteFilename.replace(process.cwd(), '').replace('/src/', '../lib/');
                         // console.log(chalk.blueBright(outputPath));
                         return Promise.resolve(outputPath);
                     },
-                    noErrorOnMissing: true
+                    noErrorOnMissing: true,
                 },
-            ]
+            ],
         }),
     ];
     if (config.debug) {
-        plugins.push(new watch_run_1["default"]());
+        plugins.push(new watch_run_1.default());
     }
     if (config.afterBuildCommand || config.afterFirstBuildCommand) {
-        var executedFirstCommand_1 = false;
+        let executedFirstCommand = false;
         plugins.push({
-            apply: function (compiler) {
-                compiler.hooks.afterEmit.tap('AfterEmitPlugin', function (compilation) {
+            apply: (compiler) => {
+                compiler.hooks.afterEmit.tap('AfterEmitPlugin', (compilation) => {
                     if (config.afterBuildCommand) {
-                        exec(config.afterBuildCommand, function (err, stdout, stderr) {
+                        exec(config.afterBuildCommand, (err, stdout, stderr) => {
                             if (stdout)
                                 process.stdout.write(stdout);
                             if (stderr)
                                 process.stderr.write(stderr);
                         });
                     }
-                    if (config.afterFirstBuildCommand && !executedFirstCommand_1) {
-                        executedFirstCommand_1 = true;
-                        exec(config.afterFirstBuildCommand, function (err, stdout, stderr) {
+                    if (config.afterFirstBuildCommand && !executedFirstCommand) {
+                        executedFirstCommand = true;
+                        exec(config.afterFirstBuildCommand, (err, stdout, stderr) => {
                             if (stdout)
                                 process.stdout.write(stdout);
                             if (stderr)
@@ -191,17 +131,17 @@ function generateWebpackConfig(buildName, moduleName, config) {
                         });
                     }
                 });
-            }
+            },
         });
     }
     if (config.analyse) {
         plugins.push(new BundleAnalyzerPlugin());
     }
     if ((es6 || config.declarations === true) && !config.declarations === false) {
-        plugins.push(new declaration_plugin_1["default"]({
+        plugins.push(new declaration_plugin_1.default({
             out: (config.filename ? config.filename : cleanModuleName) + '.d.ts',
             root: config.outputPath ? config.outputPath : './lib/',
-            debug: 'debug' in config ? config.debug : false
+            debug: 'debug' in config ? config.debug : false,
         }));
     }
     // var resolvePlugins = [
@@ -211,7 +151,7 @@ function generateWebpackConfig(buildName, moduleName, config) {
     // }),
     // ];
     var aliases = config.alias || {};
-    var postcssPlugins = [];
+    let postcssPlugins = [];
     if (!config.cssMode) {
         config.cssMode = 'mixed';
     }
@@ -227,18 +167,18 @@ function generateWebpackConfig(buildName, moduleName, config) {
                 'postcss-modules',
                 {
                     generateScopedName: utils_1.generateScopedName.bind(null, moduleName),
-                    globalModulePaths: [/tailwind/, /tailwindcss/, config.cssGlobalModulePaths].filter(Boolean)
+                    globalModulePaths: [/tailwind/, /tailwindcss/, config.cssGlobalModulePaths].filter(Boolean),
                 },
             ]);
         }
     }
     if (config.cssMode === 'tailwind' || config.cssMode === 'mixed') {
-        var lincdPackagePaths = void 0;
+        let lincdPackagePaths;
         //IF this package is including sources from another lincd package in its bundle (usually not the case)
         if (config.internals) {
             //THEN make sure that we also look for tailwind classes in those packages
             //pass the list of internal packages, or if all, pass null because it will look up all the package.json:dependencies
-            lincdPackagePaths = getLincdPackagePaths(config.internals !== '*' ? config.internals : null).map(function (path) {
+            lincdPackagePaths = getLincdPackagePaths(config.internals !== '*' ? config.internals : null).map((path) => {
                 return path + '/lib/**/*.{js,mjs}';
             });
         }
@@ -246,22 +186,21 @@ function generateWebpackConfig(buildName, moduleName, config) {
         postcssPlugins.push([
             'tailwindcss',
             {
-                content: __spreadArray(['./src/**/*.{tsx,ts}'], __read(lincdPackagePaths), false),
+                content: ['./src/**/*.{tsx,ts}', ...lincdPackagePaths],
                 safelist: productionMode
                     ? {}
                     : {
                         //in development mode we allow all classes here, so that you can easily develop
                         pattern: /./,
-                        variants: ['sm', 'md', 'lg', 'xl', '2xl']
+                        variants: ['sm', 'md', 'lg', 'xl', '2xl'],
                     },
                 theme: {
                     extend: {
-                        colors: (0, utils_1.getLinkedTailwindColors)()
-                    }
+                        colors: (0, utils_1.getLinkedTailwindColors)(),
+                    },
                 },
                 plugins: [
-                    tailwindPlugin(function (_a) {
-                        var addBase = _a.addBase, config = _a.config;
+                    tailwindPlugin(function ({ addBase, config }) {
                         //we can use LINCD CSS variables for default font color, size etc.
                         // addBase({
                         //   'h1': { fontSize: config('theme.fontSize.2xl') },
@@ -269,11 +208,11 @@ function generateWebpackConfig(buildName, moduleName, config) {
                         //   'h3': { fontSize: config('theme.fontSize.lg') },
                         // })
                     }),
-                ]
+                ],
             },
         ]);
     }
-    var rules = [
+    let rules = [
         {
             test: /\.(scss|css)$/,
             use: [
@@ -281,22 +220,22 @@ function generateWebpackConfig(buildName, moduleName, config) {
                 {
                     loader: 'css-loader',
                     options: {
-                        url: false
-                    }
+                        url: false,
+                    },
                 },
                 {
                     loader: 'postcss-loader',
                     options: {
                         postcssOptions: {
-                            plugins: postcssPlugins
-                        }
-                    }
+                            plugins: postcssPlugins,
+                        },
+                    },
                 },
                 {
                     loader: 'sass-loader',
-                    options: { sourceMap: true }
+                    options: { sourceMap: true },
                 },
-            ]
+            ],
         },
         // {
         //   test: /\.(ts|tsx)$/,
@@ -327,17 +266,17 @@ function generateWebpackConfig(buildName, moduleName, config) {
             use: [
                 {
                     loader: 'ts-loader?' +
-                        JSON.stringify(__assign({ configFile: configFile, compilerOptions: {
+                        JSON.stringify(Object.assign({ configFile: configFile, compilerOptions: {
                                 declaration: !es5,
                                 /*
                                   for webpack we overwrite the module settings of the modules' tsconfig file
                                   because we NEED esnext for code splitting. But the VM we currently use for the registry does not support esnext modules
                                  */
                                 module: 'esnext',
-                                moduleResolution: 'node'
-                            } }, config.tsConfigOverwrites))
+                                moduleResolution: 'node',
+                            } }, config.tsConfigOverwrites)),
                 },
-            ]
+            ],
         },
         // {
         //   enforce: 'pre',
@@ -356,8 +295,8 @@ function generateWebpackConfig(buildName, moduleName, config) {
         //so we fix that here by just referring directly to the typescript source instead of the transpiled js for internalised modules
         //however this means that for internalised modules THE SOURCE CODE NEEDS TO BE AVAILABLE. This is currently NOT the case with how we publish modules to yarn
         //so that means internalised modules need to be LOCALLY AVAILABLE with yarn workspaces
-        plugins.push(new webpack.NormalModuleReplacementPlugin(/lincd\/lib\//, function (resource, match) {
-            var moduleName = resource.request.match(/lincd\/lib\//)[1];
+        plugins.push(new webpack.NormalModuleReplacementPlugin(/lincd\/lib\//, (resource, match) => {
+            let moduleName = resource.request.match(/lincd\/lib\//)[1];
             if (config.internalsources.indexOf(moduleName) !== -1) {
                 console.log(colors.magenta('internal sources + ES5: Replacing /lib/ with /src/  for source-internalised module ' + moduleName));
                 resource.request = resource.request.replace('/lib/', '/src/');
@@ -371,7 +310,7 @@ function generateWebpackConfig(buildName, moduleName, config) {
         output: {
             filename: (config.filename ? config.filename : cleanModuleName) + (es5 ? '.es5' : '') + '.js',
             path: path.resolve(process.cwd(), config.bundlePath || 'dist'),
-            devtoolModuleFilenameTemplate: moduleName + '/[resource-path]'
+            devtoolModuleFilenameTemplate: moduleName + '/[resource-path]',
         },
         devtool: productionMode ? 'source-map' : 'cheap-module-source-map',
         // devtool: productionMode ? 'cheap-source-map' : 'cheap-source-map',
@@ -385,14 +324,14 @@ function generateWebpackConfig(buildName, moduleName, config) {
             extensions: ['.webpack.js', '.js', '.ts', '.tsx', '.json'],
             alias: aliases,
             // plugins: resolvePlugins,
-            fallback: { crypto: false }
+            fallback: { crypto: false },
         },
         resolveLoader: {
             modules: [
                 path.join(__dirname, 'plugins'),
                 path.join(__dirname, 'node_modules'),
                 'node_modules',
-            ]
+            ],
         },
         optimization: {
             minimize: productionMode,
@@ -400,24 +339,24 @@ function generateWebpackConfig(buildName, moduleName, config) {
                 new TerserPlugin({
                     extractComments: {
                         condition: /^\**!|@preserve|@license|@cc_on/i,
-                        banner: function (licenseFile) {
-                            return "License information can be found in ".concat(licenseFile, " and oss-licences.json");
-                        }
-                    }
+                        banner: (licenseFile) => {
+                            return `License information can be found in ${licenseFile} and oss-licences.json`;
+                        },
+                    },
                 }),
-            ]
+            ],
         },
         watch: watch,
         watchOptions: {
             ignored: ['**/*.d.ts', '**/*.js.map', '**/*.scss.json'],
-            aggregateTimeout: 500
+            aggregateTimeout: 500,
         },
         module: {
-            rules: rules
+            rules,
         },
         //See plugins/externalise-modules.ts We're passing in a function here that determines what to exclude from the bundle and what not
         //See also https://webpack.js.org/configuration/externals/
-        externals: (0, externalise_modules_1["default"])(config, es5),
+        externals: (0, externalise_modules_1.default)(config, es5),
         plugins: plugins,
         stats: {
             errorDetails: true,
@@ -426,14 +365,16 @@ function generateWebpackConfig(buildName, moduleName, config) {
             version: true,
             hash: false,
             entrypoints: false,
-            modules: false
+            modules: false,
         },
         //hide some info from output when in watch mode to keep it succinct
         //stats:{chunks:!watch,version:!watch}//hide some info from output when in watch mode to keep it succinct
         cache: {
             // https://webpack.js.org/configuration/other-options/#cache
-            type: 'filesystem'
-        }
+            type: 'filesystem',
+            // cacheDirectory: path.resolve(process.cwd(),"node_modules",".cache","webpack"),
+            // name: "lincd-webpack-cache",
+        },
     };
 }
 exports.generateWebpackConfig = generateWebpackConfig;

package/lib/index.js

@@ -13,14 +13,17 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-exports.__esModule = true;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateWebpackConfig = exports.generateGruntConfig = exports.externaliseModules = exports.DeclarationPlugin = void 0;
 var declaration_plugin_1 = require("./plugins/declaration-plugin");
-__createBinding(exports, declaration_plugin_1, "default", "DeclarationPlugin");
+Object.defineProperty(exports, "DeclarationPlugin", { enumerable: true, get: function () { return __importDefault(declaration_plugin_1).default; } });
 var externalise_modules_1 = require("./plugins/externalise-modules");
-__createBinding(exports, externalise_modules_1, "default", "externaliseModules");
+Object.defineProperty(exports, "externaliseModules", { enumerable: true, get: function () { return __importDefault(externalise_modules_1).default; } });
 var config_grunt_1 = require("./config-grunt");
-__createBinding(exports, config_grunt_1, "default", "generateGruntConfig");
-var config_webpack_1 = require("./config-webpack");
-exports.generateWebpackConfig = config_webpack_1.generateWebpackConfig;
+Object.defineProperty(exports, "generateGruntConfig", { enumerable: true, get: function () { return __importDefault(config_grunt_1).default; } });
+const config_webpack_1 = require("./config-webpack");
+Object.defineProperty(exports, "generateWebpackConfig", { enumerable: true, get: function () { return config_webpack_1.generateWebpackConfig; } });
 __exportStar(require("./utils"), exports);

package/lib/interfaces.js

@@ -1,2 +1,2 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });