lincd-cli 0.1.1 → 0.1.5

package/lib/plugins/externalise-modules.js

@@ -0,0 +1,181 @@
+"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);
+    }
+    var externalKeys = config.externals
+        ? Object.keys(config.externals)
+        : [];
+    //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]);
+        }
+        //solution to a problem that turned out not to need a solution.
+        // But if sub requests of externalized modules go wrong at some point, use this!
+        /*let rootRequest = request.substring(0, request.indexOf('/'));
+        if (externalKeys.indexOf(rootRequest) !== -1) {
+            let key = rootRequest;
+            let rest = request.substring(key.length).replace(/\//g, '.');
+            // return callback(config.externals[request]);
+            debug(
+                colors.magenta(
+                    'Excluding sub request as defined in Gruntfile: ' +
+                        request +
+                        ' -> ' +
+                        config.externals[key] +
+                        rest,
+                ),
+            );
+            return callback(null, 'var ' + config.externals[request] + rest);
+        }*/
+        //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);
+        //find @scope and the next part between 2 slashes after
+        //so @dacore/some-mod/lib/file.js
+        // --> match[0] = @dacore/some-mod
+        // --> match[1] = @dacore
+        // --> match[2] = some-mod
+        var _a = request.match(/(@[\w\-]+\/)?([\w\-]+)/), packageName = _a[0], scope = _a[1], cleanPackageName = _a[2];
+        //if this module is listed as internal module in the config (or if we internalize all modules with '*')
+        if (config &&
+            config.internals &&
+            (config.internals.indexOf(packageName) !== -1 || config.internals === '*')) {
+            //then don't exclude and don't continue this function
+            //only log once
+            if (included.indexOf(packageName) !== -1) {
+                included.push(packageName);
+            }
+            debug(colors.blue('marked internal & will be included: ' + request));
+            return callback();
+        }
+        //check if this module is a lincd module
+        var isLincd = isLincdModule(debug, packageName);
+        if (isLincd) {
+            debug(colors.magenta(packageName +
+                ' is a lincd module, imports will be excluded from this bundle and refer to a global variable instead'));
+        }
+        else {
+            debug(packageName.name +
+                ' is NOT a linked module, it will be included in the bundle');
+            return callback();
+        }
+        //remove export root path (for example with @dacore/core/lib/models: the core module has lib/ as root, so to get to the exported path dacore.core.UriResource we need to remove it)
+        //TODO: read this from package.json
+        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
+            // let module = cleanRequest
+            // 	.substr(0, firstSlash)
+            // 	.replace(/-/g, '_')
+            // 	.replace('_es5', '');
+            if (packageName == 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?
+                //Note: we don't include className here anymore, since all linked Components/Utils register themselves as libraryName._modules.moduleName.ComponentName
+                //and we don't do default exports, so the import would be `import {ComponentName} from 'foo'` OR `import {ComponentName} from 'foo/lib/components/ComponentName'`
+                //Typescript then translates `ComponentName` to `ComponentName_1.ComponentName` in the javascript output
+                //And when we build the tree, we put each individual exports of linked components directly under `lincd._modules.moduleName`
+                //so here we return the entire module as the result of such imports
+                //and ComponentName_1 will contain all things linked/exported by the module
+                //and ComponentName_1.ComponentName resolves to the desired class/function
+                targetVariable =
+                    libraryName + "._modules['" + packageName.replace(/\-/g, '_') + "']";
+                //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);
+        // }
+    };
+};
+function isLincdModule(debug, packageName) {
+    if (!lincdModules.has(packageName)) {
+        // debug(colors.green('checking ' + moduleName + '/package.json'));
+        var isLincdModule_1;
+        var modulePackage = void 0;
+        try {
+            modulePackage = require(packageName + '/package.json');
+        }
+        catch (e) {
+            debug(colors.red(packageName + '/package.json' + ' does not exist'));
+            // return callback();
+        }
+        isLincdModule_1 = modulePackage && modulePackage.lincd && true;
+        lincdModules.set(packageName, isLincdModule_1);
+    }
+    return lincdModules.get(packageName);
+}
+exports["default"] = externaliseModules;

package/lib/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  " + 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;

package/lib/utils.js

@@ -0,0 +1,127 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.flatten = exports.warn = exports.debug = exports.log = exports.generateScopedName = exports.getShapes = exports.getShapesJSONLD = exports.getPackageJSON = void 0;
+var fs = __importStar(require("fs"));
+var path = __importStar(require("path"));
+var SHACL_1 = require("lincd/lib/shapes/SHACL");
+var CoreSet_1 = require("lincd/lib/collections/CoreSet");
+var JSONLDWriter_1 = require("lincd-jsonld/lib/JSONLDWriter");
+var chalk_1 = __importDefault(require("chalk"));
+var getPackageJSON = function (root) {
+    if (root === void 0) { root = process.cwd(); }
+    var packagePath = path.join(root, 'package.json');
+    if (fs.existsSync(packagePath)) {
+        return JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    }
+    else if (root === process.cwd()) {
+        console.warn('Could not find package.json. Make sure you run this command from the root of a lincd module or a lincd yarn workspace');
+        process.exit();
+    }
+};
+exports.getPackageJSON = getPackageJSON;
+function getShapesJSONLD(moduleExports) {
+    return JSONLDWriter_1.JSONLDWriter.stringify(getShapes(moduleExports));
+}
+exports.getShapesJSONLD = getShapesJSONLD;
+function getShapes(moduleExports) {
+    var shapes = new CoreSet_1.CoreSet();
+    for (var key in moduleExports) {
+        var moduleExport = moduleExports[key];
+        // console.log(key, Object.keys(moduleExports[key]));
+        if (moduleExport.shape) {
+            // console.log(Object.keys(moduleExport.shape));
+            if (moduleExport.shape && moduleExport.shape instanceof SHACL_1.SHACL_Shape) {
+                shapes.add(moduleExport.shape);
+            }
+        }
+    }
+    return shapes;
+}
+exports.getShapes = getShapes;
+function generateScopedName(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;
+}
+exports.generateScopedName = generateScopedName;
+function log() {
+    var messages = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        messages[_i] = arguments[_i];
+    }
+    messages.forEach(function (message) {
+        console.log(chalk_1["default"].cyan(message));
+    });
+}
+exports.log = log;
+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);
+    }
+}
+exports.debug = debug;
+function warn() {
+    var messages = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        messages[_i] = arguments[_i];
+    }
+    messages.forEach(function (message) {
+        console.log(chalk_1["default"].red(message));
+    });
+}
+exports.warn = warn;
+function flatten(arr) {
+    return arr.reduce(function (a, b) {
+        return b ? a.concat(b) : a;
+    }, []);
+}
+exports.flatten = flatten;

package/package.json

@@ -1,68 +1,73 @@
-{
-  "name": "lincd-cli",
-  "version": "0.1.1",
-  "description": "Command line tools for the lincd.js library",
-  "main": "index.js",
-  "scripts": {
-    "publish-build-tools": "tsc && npm version patch && npm publish",
-    "build": "tsc"
-  },
-  "keywords": [
-    "lincd",
-    "cli",
-    "build",
-    "tools"
-  ],
-  "author": {
-    "name": "René Verheij",
-    "email": "rpwverheij@gmail.com"
-  },
-  "license": "MPL-2.0",
-  "bin": {
-    "lincd": "cli.js"
-  },
-  "dependencies": {
-    "@lodder/grunt-postcss": "^3.0.0",
-    "@types/node": "^14.14.13",
-    "chalk": "4.1.0",
-    "child-process-promise": "^2.2.1",
-    "colors": "^1.4.0",
-    "commander": "^6.2.0",
-    "css-loader": "^5.0.1",
-    "extract-text-webpack-plugin": "^4.0.0-beta.0",
-    "fs-extra": "^9.0.1",
-    "glob": "^7.1.6",
-    "grunt": "^1.3.0",
-    "grunt-concurrent": "^3.0.0",
-    "grunt-contrib-clean": "^2.0.0",
-    "grunt-exec": "^3.0.0",
-    "grunt-ts": "^6.0.0-beta.17",
-    "grunt-webpack": "^4.0.2",
-    "lincd": "*",
-    "lincd-cli": "*",
-    "load-grunt-tasks": "^5.1.0",
-    "mini-css-extract-plugin": "^1.3.3",
-    "postcss": "^8.2.1",
-    "postcss-cssnext": "^3.1.0",
-    "postcss-import": "^13.0.0",
-    "postcss-loader": "^4.1.0",
-    "postcss-modules": "^4.2.2",
-    "postcss-nested": "^5.0.3",
-    "postcss-scss": "^3.0.4",
-    "postcss-strip-inline-comments": "^0.1.5",
-    "sass": "^1.3.0",
-    "sass-loader": "10.1.0",
-    "source-map-loader": "^1.1.3",
-    "tailwindcss": "^2.0.2",
-    "terser-webpack-plugin": "^4.0.0",
-    "ts-loader": "^8.0.12",
-    "tsconfig-paths-webpack-plugin": "^3.3.0",
-    "typescript": "4.2.2",
-    "webpack": "^4.0.0",
-    "webpack-bundle-analyzer": "^3.0.0"
-  },
-  "devDependencies": {
-    "optimize-css-assets-webpack-plugin": "^5.0.4"
-  },
-  "peerDepencencies": {}
-}
+{
+	"name": "lincd-cli",
+	"version": "0.1.5",
+	"description": "Command line tools for the lincd.js library",
+	"main": "lib/index.js",
+	"scripts": {
+		"prepublishOnly": "npm exec tsc",
+		"build": "npm exec tsc"
+	},
+	"lincd_util": true,
+	"keywords": [
+		"lincd",
+		"cli",
+		"build",
+		"tools"
+	],
+	"author": {
+		"name": "René Verheij",
+		"email": "rpwverheij@gmail.com"
+	},
+	"license": "MPL-2.0",
+	"bin": {
+		"lincd": "lib/cli.js"
+	},
+	"dependencies": {
+		"@lodder/grunt-postcss": "^3.1.1",
+		"@types/node": "^14.14.13",
+		"chalk": "4.1.0",
+		"child-process-promise": "^2.2.1",
+		"colors": "^1.4.0",
+		"commander": "^6.2.0",
+		"css-loader": "^5.2.7",
+		"extract-text-webpack-plugin": "^4.0.0-beta.0",
+		"fs-extra": "^10.1.0",
+		"glob": "^7.1.6",
+		"grunt": "^1.3.0",
+		"grunt-concurrent": "^3.0.0",
+		"grunt-contrib-clean": "^2.0.0",
+		"grunt-contrib-copy": "^1.0.0",
+		"grunt-exec": "^3.0.0",
+		"grunt-ts": "^6.0.0-beta.17",
+		"grunt-webpack": "^4.0.2",
+		"license-info-webpack-plugin": "^3.0.0",
+		"lincd": "^0.2",
+		"lincd-jsonld": "^0.1.4",
+		"load-grunt-tasks": "^5.1.0",
+		"mini-css-extract-plugin": "^1.3.3",
+		"postcss": "^8.4.13",
+		"postcss-import": "^14.1.0",
+		"postcss-loader": "^4.3.0",
+		"postcss-modules": "^4.3.1",
+		"postcss-nested": "^5.0.6",
+		"postcss-scss": "^4.0.4",
+		"postcss-strip-inline-comments": "^0.1.5",
+		"require-extensions": "^0.0.4",
+		"sass": "^1.51.0",
+		"sass-loader": "^10.0",
+		"source-map-loader": "^1.1.3",
+		"tailwindcss": "^3.0.24",
+		"terser-webpack-plugin": "^4.0.0",
+		"ts-loader": "^8.0.12",
+		"tsc-hooks": "^1.1.1",
+		"tsconfig-paths-webpack-plugin": "^3.3.0",
+		"typescript": "4.2.2",
+		"webpack": "^4.0.0",
+		"webpack-bundle-analyzer": "^3.0.0",
+		"webpack-license-plugin": "^4.2.1"
+	},
+	"devDependencies": {
+		"optimize-css-assets-webpack-plugin": "^6.0.1"
+	},
+	"peerDepencencies": {}
+}