lincd-cli 0.1.0

package/config-generator.js

@@ -0,0 +1,531 @@
+"use strict";
+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));
+};
+exports.__esModule = true;
+exports.generateWebpackConfig = exports.setupGrunt = void 0;
+var declaration_plugin_1 = require("./plugins/declaration-plugin");
+var externalise_modules_1 = require("./plugins/externalise-modules");
+var watch_run_1 = require("./plugins/watch-run");
+var colors = require("colors");
+var fs = require('fs');
+var MiniCssExtractPlugin = require('mini-css-extract-plugin');
+var chalk = require('chalk');
+var webpack = require('webpack');
+var path = require('path');
+var ExtractTextPlugin = require('extract-text-webpack-plugin');
+var 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 NODE_ENV = process.env.NODE_ENV;
+var nodeProduction = NODE_ENV == 'production';
+var libraryName = 'lincd';
+function log() {
+    var messages = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        messages[_i] = arguments[_i];
+    }
+    messages.forEach(function (message) {
+        console.log(chalk.cyan(message));
+    });
+}
+function debug(config) {
+    var messages = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        messages[_i - 1] = arguments[_i];
+    }
+    if (config.debug) {
+        log.apply(void 0, messages);
+    }
+}
+function warn() {
+    var messages = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        messages[_i] = arguments[_i];
+    }
+    messages.forEach(function (message) {
+        console.log(chalk.red(message));
+    });
+}
+var flatten = function (arr) {
+    return arr.reduce(function (a, b) {
+        return b ? a.concat(b) : a;
+    }, []);
+};
+function generateGruntConfig(moduleName, config) {
+    if (config === void 0) { config = {}; }
+    return function (grunt) {
+        setupGrunt(grunt, moduleName, config);
+    };
+}
+exports["default"] = generateGruntConfig;
+var generateScopedName = function (name, filename, css) {
+    var path = require('path');
+    var file = path.basename(filename, '.scss');
+    var module = filename.match(/[\\\/]modules[\\\/]([\w\-_]+)/);
+    var moduleName;
+    if (module) {
+        moduleName = module[1];
+    }
+    else {
+        //if we cant find module name from path, we'll use a hash
+        //https://stackoverflow.com/questions/6122571/simple-non-secure-hash-function-for-javascript
+        var hash = 0;
+        if (filename.length == 0) {
+            moduleName = '_unknown';
+        }
+        else {
+            for (var i = 0; i < filename.length; i++) {
+                var char = filename.charCodeAt(i);
+                hash = (hash << 5) - hash + char;
+                hash = hash & hash; // Convert to 32bit integer
+            }
+            moduleName = hash;
+        }
+    }
+    // console.log("Module name: "+moduleName);
+    // console.log("Returning: " + moduleName + "_" + file + "_" + name);
+    return moduleName + '_' + file + '_' + name;
+};
+function setupGrunt(grunt, moduleName, config) {
+    var buildServer = !config.environment || config.environment == 'server';
+    var buildFrontend = !config.environment || config.environment == 'frontend';
+    //when not specified and we ARe building frontend OR we are compiling the server for es5.. or if simply specified, then es5 is targeted
+    var targetES5 = (!config.target && (buildFrontend || config.es5Server)) ||
+        config.target == 'es5';
+    var targetES6 = !config.target || config.target == 'es6';
+    var targets = [];
+    if (targetES5)
+        targets.push('es5');
+    if (targetES6)
+        targets.push('es6');
+    var targetLog = 'building ' + targets.join(', ');
+    if (buildServer && !buildFrontend) {
+        log(targetLog + ' lib only');
+    }
+    else if (!buildServer && buildFrontend) {
+        log(targetLog + ' dist bundles only');
+    }
+    else if (buildServer && buildFrontend) {
+        if (config.es5Server) {
+            log(targetLog + ' lib files & dist bundles');
+        }
+        else {
+            log(targetLog + ' dist bundles and es6 lib files');
+        }
+    }
+    else {
+        log('invalid configuration combination');
+    }
+    require('load-grunt-tasks')(grunt);
+    //defaults
+    grunt.registerTask('default', ['prepare-build', 'concurrent:dev']);
+    grunt.registerTask('dev', targetES6 ? ['prepare-build', 'dev-es6'] : ['prepare-build', 'dev-es5']);
+    grunt.registerTask('build', targets.map(function (target) { return 'build-' + target; }));
+    if (buildFrontend) {
+        grunt.registerTask('build-frontend', __spreadArray([
+            'prepare-build'
+        ], targets.map(function (target) { return 'webpack:build-' + target; }), true));
+    }
+    grunt.registerTask('build-production', flatten([
+        'clean:lib',
+        'prepare-build',
+        buildFrontend ? targets.map(function (target) { return 'webpack:prod-' + target; }) : null,
+        buildServer ? ['exec:build-lib'] : null,
+    ]));
+    var prepareBuild = ['postcss:cssjson'];
+    if (config.beforeBuildCommand) {
+        prepareBuild.push('exec:beforeBuildCommand');
+    }
+    //specific tasks
+    grunt.registerTask('prepare-build', prepareBuild);
+    grunt.registerTask('dev-es6-production', [
+        'prepare-build',
+        'concurrent:dev-prod',
+    ]);
+    grunt.registerTask('dev-es6', ['prepare-build', 'concurrent:dev']);
+    grunt.registerTask('dev-es5', ['prepare-build', 'concurrent:dev-es5']);
+    //build-es5 is by default just the frontend because the server is es6
+    //however some specific modules (like @dacore/module) require the typescript compiler ('build-lib') to run for es5
+    //so that core-es5 or browser-core-es5 can internalise its files
+    //this can by triggered with es5Server
+    grunt.registerTask('build-es5', flatten([
+        'postcss',
+        buildFrontend ? 'webpack:build-es5' : null,
+        config.es5Server ? 'exec:build-lib-es5' : null,
+    ]));
+    grunt.registerTask('build-es6', flatten([
+        'prepare-build',
+        buildFrontend ? 'webpack:build-es6' : null,
+        buildServer ? ['exec:build-lib'] : null,
+        'exec:shapes',
+    ]));
+    grunt.registerTask('build-lib', ['prepare-build', 'exec:build-lib']);
+    grunt.registerTask('build-production-es5', [
+        'prepare-build',
+        'webpack:prod-es5',
+        'exec:shapes',
+    ]);
+    grunt.registerTask('build-production-es6', [
+        'prepare-build',
+        'webpack:prod-es6',
+        'exec:shapes',
+    ]);
+    // log('setting grunt config');
+    grunt.initConfig({
+        exec: {
+            'build-lib': 'tsc --pretty',
+            'build-lib-es5': 'tsc --pretty -p tsconfig-es5.json',
+            beforeBuildCommand: config.beforeBuildCommand,
+            'server-dev': 'tsc -w',
+            test: 'tsc -w',
+            shapes: 'lincd shapes',
+            'css-declarations': 'tcm -p **/*.scss',
+            'postcss-modules': 'yarn postcss --use postcss-import postcss-cssnext postcss-nested postcss-modules -o build/draft.css -i scss/*'
+        },
+        postcss: {
+            options: {
+                map: true,
+                processors: [require('postcss-modules')({ generateScopedName: generateScopedName })],
+                syntax: require('postcss-scss'),
+                writeDest: false
+            },
+            cssjson: {
+                src: 'src/**/*.scss'
+            }
+        },
+        clean: {
+            lib: ['lib/']
+        },
+        concurrent: {
+            dev: flatten([
+                buildFrontend ? 'webpack:dev' : null,
+                buildServer ? 'exec:server-dev' : null,
+                // buildServer ? 'watch:css-module-transforms' : null,
+                // 'exec:css-declarations-watch'
+            ]),
+            'dev-prod': flatten([
+                buildFrontend ? 'webpack:dev-prod' : null,
+                buildServer ? 'exec:server-dev' : null,
+                // buildServer ? 'watch:css-module-transforms' : null,
+                // 'exec:css-declarations-watch'
+            ]),
+            'dev-es5': flatten([
+                buildFrontend ? 'webpack:dev-es5' : null,
+                buildServer ? 'exec:server-dev' : null,
+                // buildServer ? 'watch:css-module-transforms' : null,
+                // 'exec:css-declarations-watch'
+            ]),
+            options: {
+                logConcurrentOutput: true,
+                logTaskName: 3,
+                logBlacklist: []
+            }
+        },
+        webpack: {
+            options: {
+                stats: {
+                    chunks: false,
+                    version: false,
+                    warningsFilter: function (warning) {
+                        return warning.indexOf('There are multiple modules') !== -1;
+                    }
+                }
+            },
+            dev: generateWebpackConfig('dev', moduleName, Object.assign({
+                target: 'es6',
+                watch: true
+            }, config, config.es6, config.dev)),
+            'dev-prod': generateWebpackConfig('dev', moduleName, Object.assign({
+                target: 'es6',
+                watch: true,
+                productionMode: true
+            }, config, config.es6, config.prod)),
+            'dev-es5': generateWebpackConfig('dev-es5', moduleName, Object.assign({
+                target: 'es5',
+                watch: true
+            }, config, config.es5, config.dev)),
+            'build-es6': generateWebpackConfig('build-es6', moduleName, Object.assign({
+                target: 'es6',
+                watch: false
+            }, config, config.es6, config.dev)),
+            'build-es5': generateWebpackConfig('build-es5', moduleName, Object.assign({
+                target: 'es5',
+                watch: false
+            }, config, config.es5, config.dev)),
+            'prod-es5': generateWebpackConfig('prod-es5', moduleName, Object.assign({
+                target: 'es5',
+                watch: false,
+                productionMode: true
+            }, config, config.es5, config.prod)),
+            'prod-es6': generateWebpackConfig('prod-es6', moduleName, Object.assign({
+                target: 'es6',
+                watch: false,
+                productionMode: true
+            }, config, config.es6, config.prod))
+        }
+    });
+    grunt.config.init.exec = {
+        test: 'echo "yey"'
+    };
+    //load the npm grunt task modules
+    [
+        'grunt-webpack',
+        'grunt-exec',
+        'grunt-concurrent',
+        'grunt-contrib-clean',
+        '@lodder/grunt-postcss',
+    ].forEach(function (taskName) {
+        debug(config, 'loading grunt task ' + taskName);
+        var localPath = path.resolve(__dirname, 'node_modules', taskName, 'tasks');
+        var localPath2 = path.resolve(__dirname, '..', 'node_modules', taskName, 'tasks');
+        var workspacePath = path.resolve(__dirname, '..', '..', 'node_modules', taskName, 'tasks');
+        var nestedWorkspacePath = path.resolve(__dirname, '..', '..', '..', 'node_modules', taskName, 'tasks');
+        if (fs.existsSync(localPath)) {
+            // grunt.loadNpmTasks(taskName);
+            debug('Loading from ' + localPath);
+            grunt.task.loadTasks(localPath);
+        }
+        else if (fs.existsSync(localPath2)) {
+            // grunt.loadNpmTasks(taskName);
+            debug('Loading from ' + localPath2);
+            grunt.task.loadTasks(localPath2);
+        }
+        else if (fs.existsSync(workspacePath)) {
+            //windows, so it seems
+            debug('Loading from ' + workspacePath);
+            grunt.task.loadTasks(workspacePath);
+        }
+        else if (fs.existsSync(nestedWorkspacePath)) {
+            //mac / linux
+            debug('Loading from ' + nestedWorkspacePath);
+            grunt.task.loadTasks(nestedWorkspacePath);
+        }
+        else {
+            warn("Could not load grunt task module ".concat(taskName, "\nCould not find task at any of these paths:\n").concat(localPath, "\n").concat(localPath2, "\n").concat(workspacePath, "\n").concat(nestedWorkspacePath));
+        }
+    });
+}
+exports.setupGrunt = setupGrunt;
+function generateWebpackConfig(buildName, moduleName, config) {
+    if (config === void 0) { config = {}; }
+    if (!config.externals)
+        config.externals = {};
+    if (!config.internals)
+        config.internals = [];
+    var watch = config.watch;
+    var productionMode = nodeProduction || config.productionMode;
+    var es5 = config.target == 'es5';
+    var es6 = config.target == 'es6';
+    var configFile;
+    if (es5 && fs.existsSync('tsconfig-es5.json')) {
+        configFile = 'tsconfig-es5.json';
+    }
+    else {
+        configFile = 'tsconfig.json';
+    }
+    if (!fs.existsSync(configFile)) {
+        warn('Cannot find ' + configFile);
+        process.exit();
+    }
+    var plugins = [
+        new webpack.DefinePlugin({
+            'process.env.BROWSER': JSON.stringify(true),
+            'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV)
+        }),
+        new webpack.NoEmitOnErrorsPlugin(),
+        new ExtractTextPlugin(config.cssFileName
+            ? config.cssFileName
+            : libraryName + '.' + moduleName + '.css'),
+        new MiniCssExtractPlugin({
+            // linkType: false,
+            filename: config.cssFileName
+                ? config.cssFileName
+                : libraryName + '.' + moduleName + '.css'
+        }),
+    ];
+    if (config.debug) {
+        plugins.push(new watch_run_1["default"]());
+    }
+    if (config.afterBuildCommand) {
+        plugins.push({
+            apply: function (compiler) {
+                compiler.hooks.afterEmit.tap('AfterEmitPlugin', function (compilation) {
+                    exec(config.afterBuildCommand, function (err, stdout, stderr) {
+                        if (stdout)
+                            process.stdout.write(stdout);
+                        if (stderr)
+                            process.stderr.write(stderr);
+                    });
+                });
+            }
+        });
+    }
+    if (config.analyse) {
+        plugins.push(new BundleAnalyzerPlugin());
+    }
+    if (es6 || config.declarations === true) {
+        plugins.push(new declaration_plugin_1["default"]({
+            out: (config.filename ? config.filename : libraryName + '.' + moduleName) +
+                '.d.ts',
+            root: config.outputPath ? config.outputPath : './lib/',
+            debug: 'debug' in config ? config.debug : false
+        }));
+    }
+    var resolvePlugins = [
+        new TsconfigPathsPlugin({
+            configFile: configFile,
+            silent: true
+        }),
+    ];
+    var aliases = config.alias || {};
+    var rules = [
+        {
+            test: /\.(scss|css)$/,
+            use: [
+                MiniCssExtractPlugin.loader,
+                {
+                    loader: 'css-loader',
+                    options: {
+                        url: false
+                    }
+                },
+                {
+                    loader: 'postcss-loader',
+                    options: {
+                        postcssOptions: {
+                            plugins: {
+                                'postcss-import': {},
+                                'postcss-cssnext': {},
+                                'postcss-nested': {},
+                                // "postcss-scss": {}, //<-- only add this back if the build gets stuck on //comments in scss files, but I dont think that will be the case anymore
+                                'postcss-modules': {
+                                    //by default postcss-modules will put out a json file right next to the original css / scss file, this method defines what classnames to use
+                                    generateScopedName: generateScopedName,
+                                    globalModulePaths: [/tailwind/]
+                                },
+                                tailwindcss: {
+                                    purge: {
+                                        enabled: productionMode,
+                                        content: [
+                                            './src/**/*.tsx',
+                                            './src/**/*.ts',
+                                            //also include @dacore modules which are internalized with the "internal" config option
+                                            //imports like ... from '@dacore/module/lib/views/SomeView' will
+                                            //these modules should live in the node_modules folder of the root of the site
+                                            //TODO: remake this with multiple lincd modules
+                                            // '../../node_modules/@dacore/*/lib/**/*.js',
+                                            // './node_modules/@dacore/*/lib/**/*.js',
+                                        ]
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                {
+                    loader: 'sass-loader',
+                    options: { sourceMap: true }
+                },
+            ]
+        },
+        {
+            test: /\.tsx?$/,
+            use: [
+                {
+                    loader: 'ts-loader?' +
+                        JSON.stringify({
+                            configFile: configFile,
+                            compilerOptions: {
+                                declaration: !es5
+                            }
+                        })
+                },
+            ]
+        },
+        {
+            enforce: 'pre',
+            test: /\.js$/,
+            use: [
+                {
+                    loader: 'source-map-loader'
+                },
+            ]
+        },
+    ];
+    if (es5 && config.internalsources && config.internalsources.length > 0) {
+        //usually a module that transpiles to es5 will only have es5 code in the bundle.
+        //however a module that INTERNALISES other dacore modules will directly include es6 code from @dacore/other_modules/lib
+        //which eventually results in an import of @dacore/core being bundled as 'const =', which trips up old browsers
+        //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];
+            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/');
+                console.log(colors.magenta('internal sources + ES5: ' + resource.request));
+                console.log(colors.red("WARNING: Make sure you have the TYPESCRIPT SOURCE FILES of the modules listed as 'internal' AVAILABLE ON YOUR LOCAL MACHINE. So if you check in node_modules/your-internalised-module - that should be a symbolic link and you will find a 'src' folder with typescript files there."));
+            }
+        }));
+    }
+    return {
+        entry: config.entry ? config.entry : './src/index.ts',
+        output: {
+            filename: (config.filename ? config.filename : libraryName + '.' + moduleName) +
+                (es5 ? '.es5' : '') +
+                '.js',
+            path: path.resolve(process.cwd(), config.bundlePath || 'dist'),
+            devtoolModuleFilenameTemplate: moduleName + '/[resource-path]'
+        },
+        devtool: productionMode ? 'cheap-source-map' : 'cheap-source-map',
+        mode: productionMode ? 'production' : 'development',
+        //fixing a persistent but strange build error here that showed up once, this is a workaround. See: https://github.com/webpack-contrib/css-loader/issues/447
+        node: {
+            fs: 'empty',
+            child_process: 'empty'
+        },
+        resolve: {
+            extensions: ['.webpack.js', '.js', '.ts', '.tsx', '.json'],
+            alias: aliases,
+            plugins: resolvePlugins
+        },
+        resolveLoader: {
+            modules: [
+                path.join(__dirname, 'plugins'),
+                path.join(__dirname, 'node_modules'),
+                'node_modules',
+            ]
+        },
+        optimization: {
+            minimize: productionMode,
+            minimizer: [new TerserPlugin()]
+        },
+        watch: watch,
+        module: {
+            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),
+        plugins: plugins,
+        stats: {
+            errorDetails: config.debug,
+            chunks: false,
+            children: false,
+            version: true,
+            hash: false,
+            modules: false
+        }
+    };
+}
+exports.generateWebpackConfig = generateWebpackConfig;

package/defaults/.npmignore

@@ -0,0 +1,11 @@
+**/node_modules
+src
+.idea
+Gruntfile.js
+tsconfig.json
+tsconfig-es5.json
+modules/*/src
+modules/*/node_modules
+storage/cached
+storage/uploads
+storage/logs

package/defaults/Gruntfile.js

@@ -0,0 +1,16 @@
+var buildTools = require('@dacore/build-tools');
+module.exports = buildTools.generateGruntConfig('${module_name}', {
+	externals: {
+		react: 'React',
+		'react-dom': 'ReactDOM',
+	}, //externals: list of non-dacore modules that are already loaded and made globally available by one of the dependencies of this module
+	//internals: [],//list of dacore modules (their package name, can be with or without '@dacore/') that you want to INCLUDE in the bundle (as opposed to the module its own bundle being a dependency)
+	//alias:{},//webpack alias -> maps on type of npm path to another
+	//target:"es5"|"es6",
+	//environment:"server"|"frontend",
+	//outputPath:string,
+	//es5Server:boolean
+	//es5:{},//es5 specific config, use same properties as above
+	//es6:{},//es6 specific config, use same properties as above
+	//debug:false,//debug the build process
+});