lincd-cli 0.1.0

package/plugins/declaration-plugin.js

@@ -0,0 +1,248 @@
+"use strict";
+exports.__esModule = true;
+/// <reference path="colors.d.ts" />
+var colors = require("colors");
+var path = require("path");
+var DeclarationPlugin = /** @class */ (function () {
+    function DeclarationPlugin(options) {
+        if (options === void 0) { options = {}; }
+        this.logMessages = true;
+        this.exportRoot = '/lib';
+        this.options = options;
+        this.options['out'] = options.out
+            ? options.out
+            : './builds/declarations.d.ts';
+        this.options['config'] = options.config
+            ? options.config
+            : process.cwd() + '/daconfig.js';
+        //var moduleConfig = this.getModuleConfig();
+        this.options['root'] = options.root || this.exportRoot; //'/lib'
+        this.logMessages = options.debug ? options.debug : false;
+        this.modulePackageInfo = require(process.cwd() + '/package.json');
+        // this.debug('found package name: '+this.modulePackageInfo.name);
+    }
+    DeclarationPlugin.prototype.apply = function (compiler) {
+        var _this = this;
+        this.debug('applying');
+        //when the compiler is ready to emit files
+        // compiler.plugin('emit', (compilation,callback) =>
+        compiler.hooks.emit.tapAsync('DeclarationPlugin', function (compilation, callback) {
+            // this.debug('emitted');
+            // this.debug(Object.keys(compilation.assets));
+            //collect all generated declaration files
+            //and remove them from the assets that will be emitted
+            //NOTE: at some point we decided to overwrite declaration files between emits because sometimes only one new declaration file is emitted
+            //this may cause issues when you remove a file during the continuous building process, but better than the other way around for now
+            if (!_this.declarationFiles) {
+                _this.declarationFiles = {};
+            }
+            for (var filename in compilation.assets) {
+                if (filename.indexOf('.d.ts') !== -1) {
+                    if (_this.declarationFiles[filename]) {
+                        _this.debug('overwriting ' + filename);
+                    }
+                    _this.declarationFiles[filename] = compilation.assets[filename];
+                    // this.debug('not using: '+filename);
+                    delete compilation.assets[filename];
+                }
+            }
+            if (Object.keys(_this.declarationFiles).length == 0) {
+                _this.log('Cannot build .d.ts file because no declarations where found.'.red);
+                _this.log('Make sure to add '.yellow +
+                    '"declaration":true'.blue.bold['underline'] +
+                    ' to tsconfig.json'.yellow);
+                _this.log('Make sure to run '.yellow +
+                    'tsc'.blue +
+                    ' before running webpack'.yellow);
+                _this.log('Make sure to test for '.yellow +
+                    '/(?!.*.d.ts).ts(x?)$/'.blue.bold['underline'] +
+                    ' in the ts-loader in webpack.config.json'.yellow);
+                _this.log(('Assets: ' + Object.keys(compilation.assets).toString()).yellow);
+                callback();
+                return;
+            }
+            //var moduleConfig = this.getModuleConfig();
+            //this.debug(moduleConfig);
+            //if (moduleConfig)
+            //{
+            //combine them into one declaration file
+            var combinedDeclaration = _this.generateCombinedDeclaration(_this.declarationFiles); //moduleConfig
+            //and insert that back into the assets
+            compilation.assets[_this.options.out] = {
+                source: function () {
+                    return combinedDeclaration;
+                },
+                size: function () {
+                    return combinedDeclaration.length;
+                }
+            };
+            //get meta data from module exports
+            /*var metaRdfJson = this.generateMetaRdfJson(compilation,moduleConfig);
+            //and insert that back into the assets as [module_name].meta.json
+            compilation.assets[this.options.out.replace(".d.ts",".meta.rdf.json")] = {
+                source: function() {
+                    return metaRdfJson;
+                },
+                size: function() {
+                    return metaRdfJson.length;
+                }
+            };*/
+            //}
+            //webpack may continue now
+            callback();
+        });
+    };
+    DeclarationPlugin.prototype.debug = function () {
+        var msgs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            msgs[_i] = arguments[_i];
+        }
+        msgs.unshift('declarations:');
+        if (this.logMessages) {
+            console.log.apply(null, msgs);
+        }
+    };
+    DeclarationPlugin.prototype.log = function () {
+        var msgs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            msgs[_i] = arguments[_i];
+        }
+        msgs.unshift('declarations:');
+        console.log.apply(null, msgs);
+    };
+    DeclarationPlugin.prototype.generateCombinedDeclaration = function (declarationFiles) {
+        this.debug('generating combined declaration');
+        var declarations = '';
+        //this.debug("daCore: using config ",moduleConfig);
+        //this.debug("Combining these files:"+Object.keys(declarationFiles).toString());
+        //get current directory that webpack is run from (base of project), and replace backward slashes by forward ones to compare
+        var basePath = process.cwd().replace(/\\/g, '/') + '/';
+        this.debug('Base path:', colors.blue(basePath));
+        var npmModuleName = this.modulePackageInfo.name;
+        var moduleName = npmModuleName.replace(/\@\w+\//, '');
+        var importMap = {};
+        for (var declarationFileName in declarationFiles) {
+            //this.debug("Parsing "+declarationFileName);
+            var declarationFile = declarationFiles[declarationFileName];
+            //var data = declarationFile._value;
+            var data = declarationFile.source();
+            if (!data.split) {
+                console.warn(typeof data, declarationFileName +
+                    ' - cannot split declaration contents. Not a string?');
+                continue;
+            }
+            var lines = data.split('\n');
+            var i = lines.length;
+            while (i--) {
+                var line = lines[i];
+                //exclude empty lines
+                var excludeLine = line == '';
+                //if importing something, or re-exporting something
+                if (/import ([a-z0-9A-Z_\-\*\{\}\s,]+)/.test(line) ||
+                    /export ([a-z0-9A-Z_-\{\}\s,\*]+) from/.test(line)) {
+                    var fileImports = line.indexOf('"') !== -1
+                        ? line.match(/\"([^\"]+)\"/)
+                        : line.match(/\'([^\']+)\'/);
+                    if (fileImports && fileImports.length > 1) {
+                        var importPath = fileImports[1];
+                        //if it is importing a relative path and it is a new one
+                        if ((importPath.substr(0, 2) == './' ||
+                            importPath.substr(0, 3) == '../') &&
+                            !importMap[importPath]) {
+                            //we will replace it with the local npm module later, calc and save the absolute path for now
+                            //we parse from builds, because now TS-LOADER gives paths relative to its output folder
+                            var parsed = path.parse('./builds/' + declarationFileName);
+                            var fileDirectory = parsed.dir;
+                            var absoluteImportPath = path.resolve(fileDirectory, importPath);
+                            // this.debug('declarationfilename '+declarationFileName);
+                            // this.debug('filedir '+fileDirectory);
+                            this.debug('import ' + colors.blue(importPath), ' -> ' + colors.green(absoluteImportPath));
+                            importMap[importPath] = absoluteImportPath;
+                        }
+                    }
+                }
+                //exclude re-exports
+                //excludeLine = excludeLine || (/export ([a-z0-9A-Z_-\{\}\s,\*]+) from/).test(line);
+                //exclude local scss imports like: import "./some.scss"
+                excludeLine =
+                    excludeLine || /import ["'][a-z0-9A-Z_\-.\/\\]+.scss["']/.test(line);
+                //if defined, check for excluded references
+                if (!excludeLine &&
+                    this.excludedReferences &&
+                    line.indexOf('<reference') !== -1) {
+                    excludeLine = this.excludedReferences.some(function (reference) { return line.indexOf(reference) !== -1; });
+                }
+                if (excludeLine) {
+                    //this.debug("Excluding line "+i+': '+line);
+                    lines.splice(i, 1);
+                }
+                else {
+                    if (line.indexOf('declare ') !== -1) {
+                        lines[i] = line.replace('declare ', '');
+                    }
+                    //add tab
+                    lines[i] = lines[i];
+                }
+            }
+            //declare module '@dacore/dacore-es6/lib/sub/File' {
+            //@dacore/core/F:/wamp-new/www/dacore/modules/core/lib/ontologies/xsd
+            //F:/wamp-new/www/dacore/modules/core/lib/ontologies/xsd.d.ts
+            // var declarationFileNameWithoutBase = declarationFileName.substr(0,basePath.length) == basePath ? declarationFileName.substr(basePath.length) : declarationFileName;
+            //TS Loader now uses paths relative to output dir. so here we remove a single ../ from the path (which is in there because /builds is the output dir and /lib is the relative path of the file)
+            var fixedDeclarationPath = declarationFileName
+                .replace(/\\/g, '/')
+                .replace('../', '')
+                .replace('.d.ts', '');
+            var moduleDeclaration = npmModuleName + '/' + fixedDeclarationPath;
+            //var moduleDeclaration = npmModuleName+'/'+declarationFileName.replace(/\\/g,"/").replace(".d.ts","");
+            //this.debug('basePath:'+basePath);
+            declarations +=
+                "declare module '" +
+                    moduleDeclaration +
+                    "' {\n\t" +
+                    lines.join('\n\t') +
+                    '\n}\n\n';
+            // this.debug('fixed:'+declarationFileName+' -> '+fixedDeclarationPath);
+            this.debug('Defining module ' +
+                colors.yellow(moduleDeclaration) +
+                ' from ' +
+                colors.blue(declarationFileName));
+        }
+        for (var relativeImportPath in importMap) {
+            var absoluteImportPath_1 = importMap[relativeImportPath];
+            var npmImportModule = npmModuleName +
+                '/' +
+                absoluteImportPath_1
+                    .substr(basePath.length)
+                    .replace('.d.ts', '')
+                    .replace(/\\/g, '/');
+            //this.debug("From: "+absoluteImportPath+" to npm: "+npmImportModule);
+            this.debug('Replacing ' +
+                colors.blue(relativeImportPath) +
+                ' with ' +
+                colors.yellow(npmImportModule));
+            //wrap in quotes to omit problems with replacing partials and having to fix order of replacements
+            declarations = declarations.replace(new RegExp('(\'|")' + relativeImportPath + '(\'|")', 'g'), '"' + npmImportModule + '"');
+        }
+        var indexModulePath = this.modulePackageInfo.name + this.exportRoot + '/index';
+        this.debug('Replacing index ' +
+            colors.yellow(indexModulePath) +
+            ' with ' +
+            colors.yellow(this.modulePackageInfo.name));
+        declarations = declarations.replace("'" + indexModulePath + "'", "'" + this.modulePackageInfo.name + "'");
+        //replace alias
+        if (this.options.alias) {
+            for (var aliasKey in this.options.alias) {
+                //declarations = declarations.replace(aliasKey,this.options.alias[aliasKey]);
+                this.debug('Replacing alias ' +
+                    aliasKey +
+                    ' with ' +
+                    this.options.alias[aliasKey]);
+                declarations = declarations.replace(new RegExp(aliasKey, 'g'), this.options.alias[aliasKey]);
+            }
+        }
+        return declarations;
+    };
+    return DeclarationPlugin;
+}());
+exports["default"] = DeclarationPlugin;

package/plugins/externalise-modules.js

@@ -0,0 +1,159 @@
+"use strict";
+exports.__esModule = true;
+/// <reference path="colors.d.ts" />
+var colors = require("colors");
+var included = [];
+var exportRoot = '/lib';
+var libraryName = 'lincd';
+var lincdModules = new Map();
+//This function determines which modules that are requested by the module being built are external
+//it basically turns every import from @dacore/[something] request into a lookup for that class/object in the global daCore object (which BrowserCore maintains when modules register themselves)
+//See also: https://webpack.js.org/configuration/externals/
+var externaliseModules = function (config, es5) {
+    function debug() {
+        var msgs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            msgs[_i] = arguments[_i];
+        }
+        msgs.unshift('externals: ');
+        if (config && config.debug) {
+            console.log.apply(null, msgs);
+        }
+    }
+    function log() {
+        var msgs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            msgs[_i] = arguments[_i];
+        }
+        msgs.unshift('externals: ');
+        console.log.apply(null, msgs);
+    }
+    //return the function that is handed to webpack in the 'externals' option.
+    //it determines for each request what is external and what is not
+    return function (context, request, callback) {
+        if (config.externals && config.externals[request]) {
+            debug(colors.magenta('Excluding request as defined in Gruntfile: ' + request));
+            // return callback(config.externals[request]);
+            return callback(null, 'var ' + config.externals[request]);
+        }
+        if (config.externals && config.externals[request]) {
+            debug(colors.magenta('Excluding request as defined in Gruntfile: ' + request));
+            // return callback(config.externals[request]);
+            return callback(null, 'var ' + config.externals[request]);
+        }
+        //log(colors.gray(request));
+        //"@dacore/core/foo" => "daCore.core.foo"
+        // if (/^\@dacore\//.test(request)) {
+        //remove @dacore/
+        // if (request.indexOf('@dacore') !== 0) {
+        // 	console.warn(
+        // 		colors.red('this plugin currently works with @dacore modules only'),
+        // 	);
+        // 	return;
+        // }
+        // debug(colors.green('request: ' + request));
+        if (request.substr(0, 1) == '.' || request.substr(0, 1) == '/') {
+            // debug('skipping local');
+            callback();
+            return;
+        }
+        if (request.indexOf('lincd/') === 0 && es5) {
+            // var result = request.replace("@dacore/core/","@dacore/core-es5/");
+            // debug('Requested ES6 for ES5 target: '+colors.yellow(request) + ' => ' + colors.cyan(result));
+            debug('Requested ES6 for ES5 target: ' + colors.yellow(request));
+            // return callback(null, 'commonjs '+result);
+        }
+        //get module name without @dacore
+        // var transformed = request.substr(8);
+        var moduleName = request.indexOf('/') !== -1
+            ? request.substr(0, request.indexOf('/'))
+            : request;
+        //if this module is listed as internal module in the config
+        if (config &&
+            config.internals &&
+            config.internals.indexOf(moduleName) !== -1) {
+            //then don't exclude and don't continue this function
+            //only log once
+            if (included.indexOf(moduleName) !== -1) {
+                included.push(moduleName);
+            }
+            debug(colors.blue('marked internal & will be included: ' + request));
+            return callback();
+        }
+        //check if this module is a lincd module
+        if (!lincdModules.has(moduleName)) {
+            // debug(colors.green('checking ' + moduleName + '/package.json'));
+            var isLincdModule = void 0;
+            var modulePackage = void 0;
+            try {
+                modulePackage = require(moduleName + '/package.json');
+            }
+            catch (e) {
+                debug(colors.red(moduleName + '/package.json' + ' does not exist'));
+                return callback();
+            }
+            isLincdModule = modulePackage.lincd && true;
+            if (isLincdModule) {
+                debug(colors.magenta(modulePackage.name +
+                    ' is a lincd module, imports will be excluded from this bundle and refer to a global variable instead'));
+            }
+            else {
+                debug(modulePackage.name +
+                    ' is NOT a linked module, it will be included in the bundle');
+            }
+            lincdModules.set(moduleName, isLincdModule && true);
+        }
+        if (lincdModules.get(moduleName) !== true) {
+            return callback();
+        }
+        //remove export root path (for example with @dacore/core/lib/models/UriResource: the core module has lib/ as root, so to get to the exported path dacore.core.UriResource we need to remove it)
+        var cleanRequest = request.replace(exportRoot, '');
+        var targetVariable;
+        //expects a flat export / global tree with all the modules classes
+        //replace - by _ and remove es5, because both es6 and es5 modules will be listed under the bare module name in the global treemap
+        var firstSlash = cleanRequest.indexOf('/');
+        //if importing {x} from "lincd" (so directly from library without any paths)
+        if (firstSlash === -1 && cleanRequest == libraryName) {
+            //then we refer straight to the global object
+            targetVariable = libraryName;
+        }
+        else {
+            //for all other cases, there is slash, so lets split module before the first slash and classname after the last slash
+            var module_1 = cleanRequest
+                .substr(0, firstSlash)
+                .replace(/-/g, '_')
+                .replace('_es5', '');
+            var className = cleanRequest
+                .substr(cleanRequest.lastIndexOf('/') + 1)
+                .replace(/-/g, '_');
+            if (module_1 == libraryName) {
+                //the library itself should directly expose the main class of each file for clean variable names
+                targetVariable = libraryName;
+                //targetVariable = libraryName + '.' + className;
+            }
+            else {
+                //reading this back I'm not sure why module would be empty?
+                //this does NO LONGER include className, since Components register themselves as libraryName._modules.foo.ComponentName
+                //but we don't do default exports, so the import would be import {ComponentName} from 'foo' or 'foo/lib/components/ComponentName'
+                //which we DID rewrite to libraryName._modules.foo.ComponentName
+                //BUT TYPESCRIPT then translates var Component to ComponentName_1.ComponentName, which does not exist
+                //so NOW we point that import to the whole module, and requesting Foo_1.ComponentName will then work
+                targetVariable = libraryName + '._modules.' + module_1;
+                //import {PersonView} from 'lincd-test/lib/PersonView';
+                //lincd._modules.lincd_test
+                //PersonView_1
+                //PersonView_1.PersonView --> lincd._modules.lincd_test.PersonView
+                // targetVariable =
+                // 	libraryName +
+                // 	'.' +
+                // 	(module ? '_modules.' + module + '.' : '') +
+                // 	className;
+            }
+        }
+        debug(colors.yellow(request) + ' => ' + colors.cyan(targetVariable));
+        //See also: https://webpack.js.org/configuration/externals/
+        return callback(null, 'var ' + targetVariable);
+        // }
+    };
+};
+exports["default"] = externaliseModules;

package/plugins/watch-run.js

@@ -0,0 +1,47 @@
+// WebpackWatchRunPlugin.js
+/*
+ * This simple webpack plugin helps to identify the list of file changes, that
+ * triggered webpack re-compilation/re-build
+ */
+'use strict';
+exports.__esModule = true;
+var WatchRunPlugin = /** @class */ (function () {
+    function WatchRunPlugin() {
+    }
+    WatchRunPlugin.prototype.apply = function (compiler) {
+        compiler.hooks.watchRun.tap('WatchRun', function (comp) {
+            var changedTimes = comp.watchFileSystem.watcher.mtimes;
+            var changedFiles = Object.keys(changedTimes)
+                .map(function (file) { return "\n  ".concat(file); })
+                .join('');
+            if (changedFiles.length) {
+                console.log('====================================');
+                console.log('NEW BUILD FILES CHANGED:', changedFiles);
+                console.log('====================================');
+            }
+        });
+    };
+    return WatchRunPlugin;
+}());
+/*class WebpackWatchRunPlugin {
+    constructor(options?) {
+        if (typeof options !== "object") options = {};
+        this['options'] = options;
+    }
+
+    apply(compiler) {
+        const options = this['options'];
+        compiler.plugin("watch-run",
+            function (watching, done) {
+                const changedTimes = watching.compiler.watchFileSystem.watcher.mtimes;
+                const changedFiles = Object.keys(changedTimes)
+                    .map(file => `\n  ${file}`)
+                    .join("");
+                if (changedFiles.length) {
+                    console.log("Files modified:", changedFiles);
+                }
+                done();
+            });
+    }
+}*/
+exports["default"] = WatchRunPlugin;