binhend 2.2.9 → 2.2.11

package/index.js

@@ -6,8 +6,11 @@
 
 'use strict';
 
+const path = require('path');
+
 //___ Run scripts ___//
-require('./packages/module-alias'); //--- alias path '@' for requiring modules: require('@/any/path')
+const moduleAlias = require('./packages/module-alias'); // path alias '@' for requiring modules: require('@/any/path') - use jsconfig.json
+moduleAlias.path('@binhend/*', [ path.join(__dirname, './packages') ]); // set path alias '@binhend' for all packages to call each others when 'npm install' in another project
 
 const server = require('./packages/core/src/server');
 const Router = require('./packages/core/src/Router');

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "binhend",
-    "version": "2.2.9",
+    "version": "2.2.11",
     "description": "",
     "main": "index.js",
     "author": "Nguyen Duc Binh",

package/packages/config/package.json

@@ -7,6 +7,7 @@
     },
     "license": "MIT",
     "dependencies": {
-        "@binhend/types": "^1.0.0"
+        "@binhend/types": "^1.0.0",
+        "@binhend/validation": "^1.0.0"
     }
 }

package/packages/config/src/configuration.js

@@ -1,12 +1,13 @@
 const fs = require('fs');
 const path = require('path');
-const { isEmptyArray, isArray, isObject, mustString, isNullish, isString } = require('@binhend/types');
+const { isEmptyArray, isArray, isObject, isNullish, isString } = require('@binhend/types');
+const must = require('@binhend/validation');
 
 // @ts-ignore
 function ConfigLoader(configObject, { rootPath } = {}) {
     const configs = configObject || {};
 
-    rootPath = mustString(rootPath) || require.main.path;
+    rootPath = must.String(rootPath, { default: require.main.path });
 
     function getConfigPosition(key) {
         return key == undefined ? configs : configs[key] || (configs[key] = {});

package/packages/core/index.js

@@ -1,33 +1,6 @@
 
-const utils = require('@binhend/utils');
-const middlewares = require('@binhend/middlewares');
-const { config, ConfigLoader } = require('@binhend/config');
-const { WebBuild, binh } = require('@binhend/web');
-
-// Run scripts
-require('@binhend/module-alias'); // for format: require('@/any/path')
-
 module.exports = {
     server: require('./src/server'),
     Router: require('./src/Router'),
-    routes: require('./src/routes').routes,
-
-    cors: middlewares.cors,
-    trycatch: middlewares.trycatch,
-
-    config, ConfigLoader,
-
-    HTTPS: require('@binhend/https').HTTPS,
-    HttpError: utils.HttpError,
-    HttpCodes: utils.HttpCodes,
-    Bromise: utils.Bromise,
-
-    CSD: require('@binhend/csd'),
-
-    crypto: require('@binhend/crypto'),
-
-    types: require('@binhend/types'),
-    validation: require('@binhend/validation'),
-
-    WebBuild, binh
+    routes: require('./src/routes').routes
 };

package/packages/core/src/server.js

@@ -5,10 +5,7 @@ var server = express();
 var isCalledOnce = false;
 
 function getServer() {
-    if (isCalledOnce) {
-        server = server;
-    }
-    else {
+    if (!isCalledOnce) {
         server = express();
         isCalledOnce = true;
     }

package/packages/middlewares/package.json

@@ -8,6 +8,7 @@
     "license": "MIT",
     "dependencies": {
         "@binhend/types": "^1.0.0",
+        "@binhend/validation": "^1.0.0",
         "@binhend/utils": "^1.0.1"
     }
 }

package/packages/middlewares/src/cors.js

@@ -1,5 +1,6 @@
 
-const { isArray, mustArray, mustNumber } = require('@binhend/types');
+const { isArray } = require('@binhend/types');
+const must = require('@binhend/validation');
 
 const defaultOptions = {
     origins: [],
@@ -24,7 +25,7 @@ module.exports = (options) => {
     // Parse options
     var { origins, credentials, methods, preflightContinue, optionsSuccessStatus, exposedHeaders, allowHeaders, maxAge } = Object.assign({}, defaultOptions, options);
 
-    const allowedOrigins = mustArray(origins);
+    const allowedOrigins = must.Array(origins, { default: [] });
 
     // Create a new middleware
     return function (req, res, next) {
@@ -52,11 +53,11 @@ module.exports = (options) => {
         addHeader(res, 'Access-Control-Allow-Headers', arrayToString(allowHeaders));
 
         // Cache preflight response
-        addHeader(res, 'Access-Control-Max-Age', mustNumber(maxAge));
+        addHeader(res, 'Access-Control-Max-Age', must.Number(maxAge, { default: 0 }));
 
         // Handle preflight OPTIONS request
         if (req.method === 'OPTIONS' && !preflightContinue) {
-            var statusCode = mustNumber(optionsSuccessStatus) || 204; // 204 - No Content
+            var statusCode = must.Number(optionsSuccessStatus, { default: 204 }); // 204 - No Content
             return res.sendStatus(statusCode);
         }
 

package/packages/module-alias/index.js

@@ -1,4 +1,4 @@
 
-require('./src/alias-cjs-loader');
+module.exports = require('./src/alias-cjs-loader');
 
 // require('./alias-esm-loader'); // TODO implement this alias loader for ES Modules

package/packages/module-alias/package.json

@@ -5,8 +5,5 @@
     "exports": {
         ".": "./index.js"
     },
-    "license": "MIT",
-    "dependencies": {
-        "@binhend/web": "^1.0.0"
-    }
+    "license": "MIT"
 }

package/packages/module-alias/src/alias-cjs-loader.js

@@ -2,7 +2,6 @@
 
 const path = require('path');
 const DefaultModule = require('module');
-const { binh } = require('../../web/src/component.method'); // TODO handle this 'binh' object again, more properly, workspaces will not recognize global 'binh' 
 
 // Protect against improperly customized module constructors by other frameworks/packages
 const Module = module.constructor.length > 1 ? module.constructor : DefaultModule;
@@ -14,11 +13,6 @@ var jsconfig;
 
 try {
     jsconfig = require(jsconfigPath);
-    jsconfig.compilerOptions = jsconfig.compilerOptions || {};
-    jsconfig.compilerOptions.paths = jsconfig.compilerOptions.paths || {};
-
-    const paths = jsconfig.compilerOptions.paths;
-    paths['@binhend/*'] = [ path.join(__dirname, '../../') ];
 }
 catch (error) {
     return console.log(`[BINEND] Not found 'jsconfig.json' for alias paths.`);
@@ -27,16 +21,27 @@ catch (error) {
 const baseUrl = jsconfig?.compilerOptions?.baseUrl || '.';
 const paths = jsconfig?.compilerOptions?.paths || {};
 
+const settings = { // for external modification in run-time
+    paths,
+    webSourcePath: null,
+    webModulePath: null,
+    path: mapAliasWithFilePaths
+};
+
 /** Step 2: Create an alias map with all possible paths */
-const aliasMap = {};
+const aliasMap = {}, ENDING_WILDCARD = /\/\*$/;
 
 for (const alias in paths) {
-    const aliasPath = alias.replace('/*', ''); // Strip the '/*' for matching // TODO write regex for ending with /*
-    const originalPaths = paths[alias]; // Get the array of paths
+    const filePaths = paths[alias]; // Get the array of file paths
+    mapAliasWithFilePaths(alias, filePaths);
+}
 
-    aliasMap[aliasPath] = originalPaths.map((originalPath) => {
+function mapAliasWithFilePaths(alias, filePaths) {
+    const aliasPath = alias.replace(ENDING_WILDCARD, ''); // Strip the '/*' for matching
+
+    aliasMap[aliasPath] = filePaths.map((filePath) => {
         // Resolve each path to an absolute path
-        return path.resolve(baseUrl, originalPath.replace('/*', ''));
+        return path.resolve(baseUrl, filePath.replace(ENDING_WILDCARD, ''));
     });
 }
 
@@ -49,18 +54,22 @@ Module._resolveFilename = function (request, parent, isMain, options) {
         // Loop through the array of resolved paths for this alias
         for (const resolvedPath of aliasMap[alias]) {
             // Construct the new request path
-            var newRequest = request.replace(alias, resolvedPath);
+            var newRequest;
 
-            // BINHEND web components load each others stil requiring src paths (src file paths), not module paths (formatted file paths)
-            if (parent.filename.startsWith(binh.webModulePath)) {
-                // TODO test if this branch is acutally called.
-                newRequest = newRequest.replace(binh.webSourcePath, binh.webModulePath);
+            if (parent.filename.startsWith(settings.webModulePath)) {
+                // BINHEND web components (formatted code) load each others in build-time still requiring src paths (src file paths), not module paths (formatted file paths)
+                // parent.filename is the file location of module which makes this request by calling require()
+                newRequest = newRequest.replace(settings.webSourcePath, settings.webModulePath);
+            }
+            else {
+                newRequest = request.replace(alias, resolvedPath);
             }
 
             // Attempt to resolve the new request
             try {
                 return originalResolveFilename.call(this, newRequest, parent, isMain, options);
-            } catch (err) {
+            }
+            catch (err) {
                 // If it fails, continue to the next path
                 continue;
             }
@@ -70,3 +79,5 @@ Module._resolveFilename = function (request, parent, isMain, options) {
     // Fallback to the original resolution if no alias matches
     return originalResolveFilename.call(this, request, parent, isMain, options);
 };
+
+module.exports = settings;

package/packages/types/src/typeCheck.js

@@ -1,61 +1,36 @@
 
+// Generic
+function isPrimitive(input) {
+    return input === null || (typeof input !== 'object' && typeof input !== 'function');
+}
+
 function typeOf(input) {
     return Object.prototype.toString.call(input).slice(8, -1);
 }
 
-function isObject(input) {
-    return typeOf(input) === 'Object';
-}
+function strictTypeOf(input) {
+    if (input === null) return 'Null';
 
-function mustObject(input, defaultValue = {}) {
-    return isObject(input) ? input : isObject(defaultValue) ? defaultValue : {};
-}
+    if (typeof input === 'object') {
+        if (input instanceof Number) return 'NumberObject';
+        if (input instanceof String) return 'StringObject';
+        if (input instanceof Boolean) return 'BooleanObject';
+    }
 
-function isEmptyObject(input) {
-    return isObject(input) && Object.keys(input).length === 0;
-}
-
-const { isArray } = Array;
-
-function isEmptyArray(input) {
-    return isArray(input) && input.length === 0;
-}
-
-function mustArray(input, defaultValue = []) {
-    return isArray(input) ? input : isArray(defaultValue) ? defaultValue : [];
-}
-
-function isFunction(input) {
-    return typeof input === 'function';
+    return typeOf(input);
 }
 
+// Primitive
 function isString(input) {
-    return typeof input === 'string' || typeOf(input) === 'String';
+    return typeof input === 'string';
 }
 
 function isEmptyString(input) {
     return isString(input) && input.length === 0;
 }
 
-function mustString(input) {
-    return isString(input) ? input : '';
-}
-
 function isNumber(input) {
-    return typeof input === 'number' || typeOf(input) === 'Number';
-}
-
-function mustNumber(input, defaultValue) {
-    return isNumber(input) ? input : isNumber(defaultValue) ? defaultValue : 0;
-}
-
-function isDate(input) {
-    return typeOf(input) === 'Date' && !isNaN(input.getTime());
-}
-
-function isDateLike(value) {
-    const date = new Date(value);
-    return !isNaN(date.getTime());
+    return typeof input === 'number' && Number.isFinite(input);
 }
 
 function isBigInt(input) {
@@ -67,7 +42,7 @@ function isSymbol(input) {
 }
 
 function isBoolean(input) {
-    return typeof input === 'boolean' || typeOf(input) === 'Boolean';
+    return typeof input === 'boolean';
 }
 
 function isNull(input) {
@@ -86,27 +61,70 @@ function isNullish(input) {
     return input == null;
 }
 
+
+// Class, object
+function isObject(input) {
+    return typeOf(input) === 'Object'; // typeOf() excludes null, arrays, functions, dates, etc.
+}
+
+function isPlainObject(input) {
+    // [input != null] => not allow input values as undefined or null, since Object.getPrototypeOf(input) throws error for undefined and null.
+    return input != null && Object.getPrototypeOf(input) === Object.prototype;
+}
+
+function isEmptyObject(input) {
+    return isObject(input) && Object.keys(input).length === 0;
+}
+
+const { isArray } = Array;
+
+function isEmptyArray(input) {
+    return isArray(input) && input.length === 0;
+}
+
+function isFunction(input) {
+    return typeof input === 'function';
+}
+
+function isDate(input) {
+    return input instanceof Date && !isNaN(input.getTime());
+}
+
+function isDateLike(input) {
+    const date = new Date(input);
+    return !isNaN(date.getTime());
+}
+
+
 module.exports = {
+    // Generic
     typeOf,
+    strictTypeOf,
+    isPrimitive,
+
+    // Primitive
+    isString,
+    isEmptyString,
+    isNumber,
+    isBoolean,
+    isSymbol,
+    isBigInt,
+
+    isNull,
+    isUndefined,
+    isNullOrUndefined,
+    isNullish,
+
+    // Class, object
     isObject,
+    isPlainObject,
     isEmptyObject,
-    mustObject,
+
     isArray,
     isEmptyArray,
-    mustArray,
+
     isFunction,
-    isNull,
-    isUndefined,
-    isNullOrUndefined,
-    isNullish,
-    isBoolean,
-    isNumber,
-    mustNumber,
-    isString,
-    isEmptyString,
-    mustString,
-    isSymbol,
-    isBigInt,
+
     isDate,
     isDateLike
 };

package/packages/web/package.json

@@ -10,6 +10,7 @@
         "@binhend/core": "^1.0.0",
         "@binhend/types": "^1.0.0",
         "@binhend/config": "^1.0.0",
+        "@binhend/validation": "^1.0.0",
         "express": "^4.17.1",
         "js-beautify": "^1.15.1",
         "uglify-js": "^3.17.4",

package/packages/web/src/WebBuild.js

@@ -1,13 +1,15 @@
 
 const path = require('path');
-// @ts-ignore
-const { isEmptyString, isString, mustString } = require('@binhend/types');
+const express = require('express');
+
+const { server } = require('@binhend/core');
+const { isEmptyString, isString } = require('@binhend/types');
+const must = require('@binhend/validation');
+const moduleAlias = require('@binhend/module-alias');
+
 const ComponentFormat = require('./component.format');
 const ComponentBuild = require('./component.build');
 const Component = require('./component');
-// @ts-ignore
-const { server } = require('@binhend/core');
-const express = require('express');
 
 const DEFAULT_DIR_BUILD = 'build';
 const DEFAULT_DIR_BUILD_WEB = 'web';
@@ -26,7 +28,7 @@ function WebBuild(source, { output, external } = {}) {
 
     var web = path.resolve(output, DEFAULT_DIR_BUILD_WEB);
     var module = path.resolve(output, DEFAULT_DIR_BUILD_MODULE);
-    var external = mustString(external) || DEFAULT_DIR_BUILD_EXTERNAL;
+    var external = must.String(external, { default: DEFAULT_DIR_BUILD_EXTERNAL });
 
     this.bundle = () => {
         Component.isLazy = false;
@@ -57,15 +59,11 @@ function WebBuild(source, { output, external } = {}) {
 
     setTimeout(() => {
         server().use(express.static(web));
-        // @ts-ignore
         server().get('/*', (req, res) => res.sendFile('index.html', { root: web }));
     });
 
-    // @ts-ignore
-    binh.webModulePath = module;
-    // @ts-ignore
-    binh.webSourcePath = source;
-
+    moduleAlias.webModulePath = module;
+    moduleAlias.webSourcePath = source;
 }
 
 module.exports = {

package/packages/web/src/component.js

@@ -1,110 +1,5 @@
-// @ts-nocheck
 
-const { readdir, statSync, writeFile, existsSync, mkdirSync, copyFile, readFileSync } = require('fs');
-const { join, dirname, parse } = require('path');
-const CodeFormat = require('./code');
-
-// TODO
-// [-] Enhance code by removing sync logics (except for existsSync, mkdirSync): readdir, readFileSync, (statSync?)
-// [-] Able to minify/beautify generated files
-
-function generate(source, destination) {
-    if (source == undefined) return;
-    console.log('[BINHEND][WEB-BUILD] Start building components from:', source);
-    console.log('[BINHEND][WEB-BUILD] to:', destination);
-    processDirectory(source, source, destination);
-}
-
-function processDirectory(root, current, destination) {
-    readdir(current, function (error, dirents) {
-        if (error) {
-            showError('Failed scanning directory', current, error);
-            return;
-        }
-
-        dirents.forEach(function (dirent) {
-            var filepath = join(current, dirent);
-
-            try {
-                var stat = statSync(filepath);
-
-                if (stat.isFile()) {
-                    var outpath = filepath.replace(root, destination);
-                    ensureDirectoryExistence(outpath);
-
-                    if (parse(dirent).ext !== '.js') {
-                        return cloneFile(filepath, outpath);
-                    }
-
-                    try {
-                        var component = require(filepath);
-                    }
-                    catch (error) {
-                        var content = readFileSync(filepath, { encoding: 'utf8', flag: 'r' });
-                        var isComponent = content.match(/\s*binh\s*.(ui|service|style)\s*\(\s*module\s*,.*\)/);
-                        if (isComponent) {
-                            showError('Failed requiring module', filepath, error);
-                            return;
-                        }
-                        return cloneFile(filepath, outpath);
-                    }
-
-                    if (!(component instanceof Function) || component.constructor !== Component) {
-                        return cloneFile(filepath, outpath);
-                    }
-
-                    var code = joinCodes(component, root);
-
-                    writeFile(outpath, code, { encoding: 'utf8', flag: 'w' }, function(error) {
-                        if (error) {
-                            showError('Failed writing file', filepath, error);
-                            return;
-                        }
-                    });
-                }
-                else if (stat.isDirectory()) {
-                    processDirectory(root, filepath, destination);
-                }
-            }
-            catch (error) {
-                showError('Failed processing file', filepath, error);
-            }
-        });
-    });
-}
-
-function ensureDirectoryExistence(filepath) {
-    var dirpath = dirname(filepath);
-    if (existsSync(dirpath)) return true;
-    ensureDirectoryExistence(dirpath);
-    mkdirSync(dirpath);
-}
-
-function joinCodes(component, root) {
-    var fullcode = CodeFormat.prequire(component, [
-        CodeFormat.bundle(component, root),
-        CodeFormat.htmltags(component)
-    ]);
-
-    return fullcode;
-}
-
-function cloneFile(filepath, outpath) {
-    copyFile(filepath, outpath, function(error) {
-        if (error) {
-            showError('Failed copying file to', outpath, error);
-        }
-    });
-}
-
-function showError(message, id, error) {
-    console.log(`[BINHEND][WEB-BUILD] ${message}:`, id);
-    console.log('[BINHEND][WEB-BUILD] Error details:', error);
-}
-
-var Component = {
-    generate,
+module.exports = {
+    isLazy: false,
     minification: false
 };
-
-module.exports = Component;