cob-cli 2.23.0 → 2.26.0

package/templates/frontend/easy/webapp/vue.config.js

@@ -1,66 +0,0 @@
-const DASH_DIR = process.env.npm_package_config_dash_dir
-const SERVER = process.env.npm_config_remote_server
-   || ("https://" + process.env.npm_package_config_remote_server);
-
-module.exports = {
-  // temos que fixar o directorio onde colocamos o build,
- //  para podermos usar o dashboard.html que é gerado sem o editar
-  // NOTA: o path relativo não funciona bem com o npm run serve
-  // mas queremos que o build seja relativo, para ser mais fléxivel
-  publicPath: process.env.NODE_ENV === 'production'
-    ? './localresource/' + DASH_DIR + '/dist/'
-    : '/' + DASH_DIR + '/',
-
-  configureWebpack: {
-    // deve ser igual ao que é usado no afterDeps do public/dashboard.html
-    externals: {
-      vue: 'Vue',
-      vuetify: 'Vuetify',
-      axios: 'axios',
-      marked: 'marked'
-    }
-  },
-
-  // seguindo https://cli.vuejs.org/guide/webpack.html
-  chainWebpack: config => {
-    // para não termos chunks
-    config.optimization.delete('splitChunks');
-    // fazemos assim em vez de usar o pages, que confunde o publicPath
-    config
-      .plugin('html')
-      .tap(args => {
-        args[0].template = 'public/dashboard.html'
-        args[0].filename = 'dashboard.html'
-        args[0].inject = false
-        args[0].minify = false
-        return args
-      })
-  },
-
-  devServer: {
-    proxy: {
-      [`^/userm/localresource/${DASH_DIR}`]: {
-        //logLevel: 'debug',
-        target: "http://localhost:8080",
-        pathRewrite: path =>
-          path.replace(
-            "/userm/localresource/" + DASH_DIR,
-            "/" + DASH_DIR
-          )
-      },
-      "^/userm|^/recordm|^/es|^/logm|^/kibana": {
-        //logLevel: 'debug',
-        target: SERVER,
-        ws: true,
-        changeOrigin: true
-      },
-      "/get_user_lang|/security|/localresource|/userm|/user|/reportm|/cas": {
-        //logLevel: 'debug',
-        target: SERVER,
-        ws: true,
-        changeOrigin: true,
-        pathRewrite: path => path.replace("/userm/userm", "/userm")
-      }
-    }
-  }
-}

package/templates/frontend/formatList/currency/css/_format_currency.css

@@ -1,11 +0,0 @@
-.currency_negative {
-	color:red;
-}
-.currency_positive {
-	color:green;
-}
-
-.currency_negative::after,
-.currency_positive::after {
-	content: ' €';
-}

package/templates/frontend/formatList/currency/css/customizations.__MERGE__.css

@@ -1 +0,0 @@
-@import "_format_currency.css";

package/templates/frontend/formatList/currency/js/cob/_format_currency.js

@@ -1,11 +0,0 @@
-cob.custom.customize.push(function (core, utils, ui) {
-    core.customizeAllColumns("*", (node, esDoc, colDef) => {
-        // Test $style[currency], by it self or with other styles 
-        if(/\$style\[([^,]+,)*currency(,[^,]+)*\]/.exec(colDef.fieldDefDescription) != null) {
-            let value = esDoc[colDef.field] ? esDoc[colDef.field][0] : null
-            if(value) {
-                node.classList.add((value[0] === "-") ? "currency_negative" : "currency_positive")
-            }
-        }
-    })
-})

package/templates/frontend/formatList/currency/js/customizations2.__MERGE__.js

@@ -1 +0,0 @@
-import("./cob/_format_currency.js");

package/templates/gitignore

@@ -1,14 +0,0 @@
-.DS_Store
-node_modules
-.idea
-*.iml
-.env.json
-.test.in.execution
-
-# NativeScript application
-hooks
-platforms
-
-# CoB Enviroment management temporary files
-*ENV__DELETE__.*
-*ENV__ORIGINAL_BACKUP__.*

package/templates/keywords/audit/backend/scripts/_audit.groovy

@@ -1,83 +0,0 @@
-import groovy.transform.Field
-import org.codehaus.jettison.json.JSONObject
-
-import com.google.common.cache.*
-import java.util.concurrent.TimeUnit
-
-// ========================================================================================================
-if (msg.product != "recordm-definition" && msg.product != "recordm" ) return
-
-@Field static cacheOfAuditFieldsForDefinition = CacheBuilder.newBuilder()
-        .expireAfterWrite(5, TimeUnit.MINUTES)
-        .build();
-
-if (msg.product == "recordm-definition") cacheOfAuditFieldsForDefinition.invalidate(msg.type)
-
-// ========================================================================================================
-def auditFields = cacheOfAuditFieldsForDefinition.get(msg.type, { getAuditFields(msg.type) })
-if (auditFields.size() > 0
-	&& msg.product == "recordm"
-	&& msg.user != "integrationm"
-	&& msg.action =~ "add|update" ) {
-
-	def updates = getAuditFieldsUpdates(auditFields,msg.instance.fields)
-	def result = actionPacks.recordm.update(msg.type, "recordmInstanceId:" + msg.instance.id, updates);
-	if(updates) log.info("[\$audit] UPDATE '${msg.type}' id:${msg.instance.id}, updates: ${updates}, result:${result.getStatus()} | ${result.getStatusInfo()} ");
-}
-
-// ========================================================================================================
-def getAuditFieldsUpdates(auditFields,instanceFields) {
-	def updates = [:]
-	auditFields.each { auditField ->
-		if( auditField.op == "creator" && msg.action == "update" && msg.value(auditField.name) != null) return // 'creator' fields are only changed in 'update' if the previous value was empty (meaning it was a field that was not visible)
-		if( msg.action == 'update' && !msg.diff) return // Only continues if there is at least one change
-		if( auditField.args == "uri") {
-			updates << [(auditField.name) : actionPacks.get("userm").getUser(msg.user).data._links.self]
-
-		} else if( auditField.args == "username") {
-			updates << [(auditField.name) : msg.user]
-			
-		} else if( auditField.args == "time") {
-			if(msg.action == 'add' && Math.abs(msg.value(auditField.name, Long.class)?:0 - msg._timestamp_) < 30000) return // Ignore changes less then 30s
-			updates << [(auditField.name) : "" + msg._timestamp_]
-		}
-	}
-	return updates
-}
-
-// ========================================================================================================
-def getAuditFields(definitionName) {
-	log.info("[\$audit] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
-
-	// Obtém detalhes da definição
-	def definitionEncoded = URLEncoder.encode(definitionName, "utf-8").replace("+", "%20")
-	def resp = actionPacks.rmRest.get( "recordm/definitions/name/${definitionEncoded}".toString(), [:], "integrationm");
-	JSONObject definition = new JSONObject(resp);
-
-	def fieldsSize = definition.fieldDefinitions.length();
-
-	def fields = [:]
-	(0..fieldsSize-1).each { index ->
-		def fieldDefinition  = definition.fieldDefinitions.getJSONObject(index)
-		def fieldDescription = fieldDefinition.getString("description")
-		if(fieldDescription){
-			def fieldDefId       = fieldDefinition.get("id");
-			def fieldName        = fieldDefinition.get("name");
-			fields[fieldDefId]   = [name:fieldName, description: fieldDescription]
-		}
-	}
-
-	// Finalmente obtém a lista de campos que é necessário calcular
-	def auditFields = [];
-	fields.each { fieldId,field -> 
-		def matcher = field.description =~ /[$]audit\.(creator|updater)\.(username|uri|time)/
-		if(matcher) {
-			def op = matcher[0][1]
-			def arg = matcher[0][2]
-			auditFields << [fieldId: fieldId, name:field.name, op : op, args: arg]
-		}
-	}
-	log.info("[\$audit] Update 'auditFields' for '$definitionName': $auditFields");
-	log.info("[\$audit] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
-	return auditFields
-}

package/templates/keywords/audit/frontend/js/cob/_audit.js

@@ -1,24 +0,0 @@
-//----------------- $audit  ------------------------
-cob.custom.customize.push(function (core, utils, ui) {
-    core.customizeAllInstances((instance, presenter) => 
-    {
-        let userFPs = presenter.findFieldPs( fp => /[$]audit\.(creator|updater)\.(username|uri|time)/.exec(fp.field.fieldDefinition.description) )
-        userFPs.forEach( fp => {
-            fp.disable()
-            if( presenter.isGroupEdit() ) return; // Don't do nothing in group edit
-            if(/[$]audit\.updater\./.exec(fp.field.fieldDefinition.description) && !instance.isNew()) return //Don't do nothing if $audit.updater.* and it's an update interface (updates will only be changed by the backend)
-            if(fp.isVisible() && /[$]audit\.creator\./.exec(fp.field.fieldDefinition.description) && !instance.isNew()) return //Se campo visível e é um creator não faz nada 
-            
-            if(/[$]audit\.(creator|updater)\.username/.exec(fp.field.fieldDefinition.description)) {
-                fp.setValue(core.getCurrentLoggedInUser())
-            }
-            if(/[$]audit\.(creator|updater)\.uri/.exec(fp.field.fieldDefinition.description)) {
-                fp.setValue(core.getCurrentLoggedInUserUri())
-            }
-            if(/[$]audit\.(creator|updater)\.time/.exec(fp.field.fieldDefinition.description)) {               
-                fp.setValue(Date.now())
-                setInterval(() =>  fp.setValue(Date.now()),15000)
-            }
-        })
-    })
-});

package/templates/keywords/audit/frontend/js/customizations2.__MERGE__.js

@@ -1 +0,0 @@
-import("./cob/_audit.js");

package/templates/keywords/calc/backend/scripts/_calc.groovy

@@ -1,161 +0,0 @@
-import groovy.transform.Field
-import org.codehaus.jettison.json.JSONObject
-
-import java.math.RoundingMode;
-
-import com.google.common.cache.*
-import java.util.concurrent.TimeUnit
-
-// ========================================================================================================
-if (msg.product != "recordm-definition" && msg.product != "recordm" ) return
-
-@Field static cacheOfCalcFieldsForDefinition = CacheBuilder.newBuilder()
-        .expireAfterWrite(5, TimeUnit.MINUTES)
-        .build();
-
-if (msg.product == "recordm-definition") cacheOfCalcFieldsForDefinition.invalidate(msg.type)
-
-// ========================================================================================================
-def calculationFields = cacheOfCalcFieldsForDefinition.get(msg.type, { getAllCalculationFields(msg.type) })
-if (calculationFields.size() > 0
-	&& msg.product == "recordm"
-	&& msg.user != "integrationm"
-	&& msg.action =~ "add|update" ){
-
-	def updates = executeCalculations(calculationFields, msg.instance.fields)
-    def result = actionPacks.recordm.update(messageMap.type, "recordmInstanceId:" + messageMap.instance.id, updates);
-	if(updates) log.info("[\$calc] UPDATE '${msg.type}' id:${msg.instance.id}, updates: ${updates}, result:${result.getStatus()} | ${result.getStatusInfo()} ");
-}
-
-// ==================================================
-def getCalculationOperation(fieldDescription) {
-	def matcher = fieldDescription =~/.*[$]calc.([^(]+)/
-	def op = matcher[0][1]
-	return op
-}
-
-// ==================================================
-def getCalculationArgNames(fieldDescription) {
-	def matcher = fieldDescription =~/.*[$]calc.[^(]+\(([^(]+)\)/
-	def argNamesArray = matcher[0][1].tokenize(",")
-	return argNamesArray;
-}
-
-// ========================================================================================================
-def executeCalculations(calculationFields,instanceFields) {
-	def updates = [:]
-	def atLeastOneChangeFlag = false;
-	def passCount = 0;
-	def temporaryResults = [:]
-	while(passCount++ == 0 || atLeastOneChangeFlag && passCount < 10) { //10 is just for security against loops
-		atLeastOneChangeFlag = false
-		calculationFields.each { calculation ->
-			def novoResultado = evaluateExpression(calculation,instanceFields,temporaryResults)
-			if(temporaryResults[calculation.fieldId] != novoResultado ) {
-				// log.info("[\$calc] {{passCount:${passCount}, field:${calculation.name} (${calculation.fieldId})" + 
-				// 		", calcType:${calculation.op}(${calculation.args})" +
-				// 		", previousResult:${temporaryResults[calculation.fieldId]}" +
-				// 		", calcValue:$novoResultado}}");
-
-				temporaryResults[calculation.fieldId] = novoResultado;
-				updates << [(calculation.name) : novoResultado]
-				atLeastOneChangeFlag = true
-			}
-		}
-	}
-	return updates
-}
-
-// ==================================================
-def evaluateExpression(calculation,instanceFields,temporaryResults) {
-	// Realizar operação
-	def resultado = new BigDecimal(0)
-	def args = getCalculationArguments(calculation,instanceFields,temporaryResults)
-
-	if(calculation.op == "multiply" && args.size() > 0) {
-		resultado = 1
-		args.each { arg -> resultado = resultado.multiply(new BigDecimal(arg?.trim() ?: 0)) }
-
-	} else if (calculation.op == "divide" && args.size() == 2 && (args[1]?:0 != 0)) {
-		resultado = new BigDecimal(args[0]?.trim() ?:0);
-		resultado = resultado.divide(new BigDecimal(args[1]?.trim()), 8, RoundingMode.HALF_UP)
-
-	} else if(calculation.op == "sum") {
-		args.each { arg -> resultado = resultado + new BigDecimal(arg?.trim() ?: 0)}
-
-	} else if (calculation.op == "subtract" && args.size() == 2) {
-		resultado = new BigDecimal(args[0]?.trim() ?: 0);
-		resultado = resultado.subtract(new BigDecimal(args[1]?.trim() ?: 0))
-	}
-	return resultado.stripTrailingZeros().toPlainString()
-}
-
-// ==================================================
-def getCalculationArguments(calculation,instanceFields,temporaryResults) {
-	def values = calculation.args.collect { argName,argFieldIds ->
-		(""+argName).isNumber()
-			? argName * 1
-			: getAllAplicableValuesForVarName(calculation.fieldId,argName,argFieldIds,instanceFields,temporaryResults)
-	}
-	return values.flatten()
-}
-
-// ==================================================
-def getAllAplicableValuesForVarName(fieldId,varName,varFieldIds,instanceFields,temporaryResults) {
-	// log.info("[\$calc] find '$varName'($varFieldIds) in $instanceFields (temporaryResults=$temporaryResults) ");
-	def relevantFields = instanceFields.findAll{ instField -> varFieldIds.indexOf(instField.fieldDefinition.id) >= 0 }
-	
-	def result = varFieldIds.collect { varFieldId ->
-		if(temporaryResults[varFieldId] != null) { 
-			return temporaryResults[varFieldId]
-		} else {
-			return  temporaryResults[varFieldId] = instanceFields.findAll{ instField -> varFieldId == instField.fieldDefinition.id }?.collect { it.value }
-		}
-	}
-	// log.info("[\$calc] values for '$varName'($varFieldIds) = $result (temporaryResults=$temporaryResults) " );
-	return result.flatten()
-}
-
-// ========================================================================================================
-def getAllCalculationFields(definitionName) {
-	log.info("[\$calc] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
-
-	// Obtém detalhes da definição
-	def definitionEncoded = URLEncoder.encode(definitionName, "utf-8").replace("+", "%20")
-	def resp = actionPacks.rmRest.get( "recordm/definitions/name/${definitionEncoded}".toString(), [:], "integrationm");
-	JSONObject definition = new JSONObject(resp);
-
-	def fieldsSize = definition.fieldDefinitions.length();
-
-	def fields = [:]
-	(0..fieldsSize-1).each { index ->
-		def fieldDefinition  = definition.fieldDefinitions.getJSONObject(index)
-		def fieldDescription = fieldDefinition.get("description")
-		def fieldDefId       = fieldDefinition.get("id")
-		def fieldName        = fieldDefinition.get("name");
-		fields[fieldDefId]   = [name:fieldName, description: fieldDescription]
-	}
-
-	// Finalmente obtém a lista de campos que é necessário calcular
-	def calculationFields = [];
-	def previousId
-	fields.each { fieldId,field ->
-		if(field.description.toString() =~ /[$]calc\./) {
-			def op = getCalculationOperation(field.description)
-			def args = getCalculationArgNames(field.description)
-			argsFields = [:]
-			args.each { arg ->
-				if(arg == "previous") {
-					argsFields[arg] = [previousId]
-				} else {
-					argsFields[arg] = fields.findAll{fId,f -> f.description?.toString() =~ /.*[$]$arg.*/ }.collect { fId,f -> fId}
-				}
-			}
-			calculationFields << [fieldId: fieldId, name:field.name, op : op, args : argsFields]
-		}
-		previousId = fieldId
-	}
-	log.info("[\$calc] Update 'calculationFields' for '$definitionName': $calculationFields");	
-	log.info("[\$calc] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
-	return calculationFields
-}

package/templates/keywords/calc/frontend/js/cob/_calc.js

@@ -1,193 +0,0 @@
-//----------------- Enable do $calc  ------------------------
-cob.custom.customize.push(function (core, utils, ui) {
-    core.customizeAllInstances((instance, presenter) => calc_automation(instance, presenter))
-
-    function calc_automation(instance, presenter) {
-        registerAndExecuteCalculation()
-        // Repeat 'executeCalculations' every 200ms to compensante not reacting to deletion of duplicate fiels (no event available to subscribe) or changes in top hierarchy (see specific TODO below)
-        setInterval(executeCalculations,2000)
-
-        //=========================================================
-        // Support functions
-        //=========================================================
-        function registerAndExecuteCalculation() {
-            registerExecuteCalculationsOnChanges()
-            executeCalculations()
-        }
-
-        //=========================================================
-        function getAllCalculationsFields() {
-            return presenter
-                .findFieldPs( fp => /[$]calc\.(.*)/.exec(fp.field.fieldDefinition.description) )
-                .map( calculationFp => {
-                    calculationFp.disable()
-                    return {
-                        fp: calculationFp,
-                        op: getCalculationOperation(calculationFp),
-                        args: getCalculationArguments(calculationFp)
-                    }
-                })
-
-            //=========================================================
-            function getCalculationOperation(calculationFp) {
-                let fieldDescription = calculationFp.field.fieldDefinition.description
-                let expr = fieldDescription.substr(fieldDescription.indexOf("$calc.")+6)
-                let matcher = /([^(]+)/
-                let op = expr.match(matcher)[1]
-                return op
-            }
-
-            //=========================================================
-            function getCalculationArguments(calculationFp) {
-                let argNames = getCalculationArgNames(calculationFp)
-                return argNames
-                    .map( argName => isNaN(argName)
-                        ? getAllAplicableFpsForVarName(calculationFp, argName) // É uma variável, retorna todos os fp associados
-                        : argName * 1 // é uma constante numérica
-                    )
-                    .flat()
-
-                //=========================================================
-                function getCalculationArgNames(calculationFp) {
-                    let fieldDescription = calculationFp.field.fieldDefinition.description;
-                    let expr = fieldDescription.substr( fieldDescription.indexOf("$calc.") + 6 );
-                    let matcher = /[^(]+\(([^(]+)\)/;
-                    let argNamesArray = expr.match(matcher)[1].split(",");
-                    return argNamesArray;
-                }
-
-                //=========================================================
-                function getAllAplicableFpsForVarName(calculationFp, varName) {
-                    let result
-                    if(varName === "previous") {
-                        let todosCampos = presenter.findFieldPs(() => true).map(fp => fp.field.id )
-                        result = presenter.findFieldPs(fp => fp.field.id === todosCampos[todosCampos.indexOf(calculationFp.field.id)-1])
-                    } else {
-                        result = presenter.findFieldPs( fp => fp.field.fieldDefinition.description && fp.field.fieldDefinition.description.includes("$"+varName))
-                    }
-                    return result
-                }
-            }
-        }
-
-        //=========================================================
-        function registerExecuteCalculationsOnChanges() {
-            let calculations = getAllCalculationsFields()
-            calculations.forEach(
-                calculation => calculation.args.forEach( arg => {
-                    // eventos de field changes de qualquer das variáveis (ou seja, sempre que o argumento não for um número)
-                    if(isNaN(arg)) {
-                        if(arg.field.fieldDefinition.duplicable) {
-                            //O caso de campos duplicáveis é diferente porque é necessário voltar a registar tudo e só depois calcular
-                            presenter.onFieldChange(arg.field.fieldDefinition.name, () => registerAndExecuteCalculation() )
-                            // TODO: reagir à remoção de um duplicado
-                        } else {
-                            //No caso de campos normais só é necessário calcular tudo quando uma dependência muda
-                            presenter.onFieldChange(arg, () => executeCalculations() )
-                        }
-                        //Caso o campo tenha uma condição também temos de reagir a mudanças na condição. TODO: reagir a toda a cadeia superior (sempre que haja uma condição ou seja duplicável) e não apenas condição directa
-                        let conditionFp = presenter.findFieldPs(fp => fp.field.id === arg.field.fieldDefinition.conditionSource)
-                        if(conditionFp.length) presenter.onFieldChange(conditionFp[0].field.fieldDefinition.name, registerAndExecuteCalculation )
-
-                    }
-                })
-            )
-        }
-
-        //=========================================================
-        function executeCalculations() {
-            const debug = false
-            if(debug) console.group("[Calculations] eval all $calc");
-            let calculations = getAllCalculationsFields() // Get fresh values
-            let t0 = performance.now();
-            calculations.forEach( calculation => {
-                let t0parcial = performance.now();
-                let novoResultado = "" + evaluateExpression(calculation)
-                if(calculation.fp.getValue() != novoResultado ) {
-                    calculation.fp.setValue(novoResultado)
-                    if(debug) console.groupCollapsed("[Calculations] updated field ", calculation.fp.field.fieldDefinition.id, " '", calculation.fp.field.fieldDefinition.name, "' with ",novoResultado)
-                    if(debug) console.debug("[Calculations]", calculation.op)
-                    if(debug) console.debug("[Calculations]", calculation.args.map(arg => isNaN(arg) ? arg.field.fieldDefinition : arg))
-                    if(debug) console.debug("[Calculations] subcalc took " + (performance.now() - t0parcial) + " milliseconds.");
-                    if(debug) console.groupEnd()
-
-                }
-            })
-            if(debug) console.debug("[Calculations] total calc took " + (performance.now() - t0) + " milliseconds.");
-            if(debug) console.groupEnd();
-            return ;
-
-            //=========================================================
-            function evaluateExpression(calculation) {
-                // Obter valores para variaveis
-                let values = calculation.args
-                                .filter(arg => !isNaN(arg) || arg.isVisible())
-                                .map(arg =>
-                                    arg.getValue
-                                    ? isNaN(arg.getValue() * 1)
-                                        ? 0
-                                        : parseFloat(arg.getValue())
-                                    : arg
-                                );
-
-                // Realizar operação
-                let resultado = new BigDecimal(0)
-                if (calculation.op === "multiply" && values.length > 0) {
-                    resultado = new BigDecimal(1);
-                    values.forEach(value => resultado = resultado.multiply(new BigDecimal(value)))
-
-                } else if (calculation.op === "divide" && values.length === 2 && values[1] !== 0 ) {
-                    resultado = new BigDecimal(values[0]);
-                    resultado = resultado.divide(new BigDecimal(values[1]))
-
-                } else if (calculation.op === "sum") {
-                    values.forEach(value => resultado = resultado.add(new BigDecimal(value)))
-
-                } else if (calculation.op === "subtract" && values.length === 2) {
-                    resultado = new BigDecimal(values[0]);
-                    resultado = resultado.subtract(new BigDecimal(values[1]))
-                }
-                return resultado
-            }
-        }
-    }
-
-    // From https://stackoverflow.com/questions/16742578/bigdecimal-in-javascript
-    class BigDecimal {
-        // Configuration: constants
-        static DECIMALS = 8; // number of decimals on all instances
-        static ROUNDED = true; // numbers are truncated (false) or rounded (true)
-        static SHIFT = BigInt("1" + "0".repeat(BigDecimal.DECIMALS)); // derived constant
-        constructor(value) {
-            if (value instanceof BigDecimal) return value;
-            let [ints, decis] = String(value).split(".").concat("");
-            this._n = BigInt(ints + decis.padEnd(BigDecimal.DECIMALS, "0")
-                                        .slice(0, BigDecimal.DECIMALS)) 
-                    + BigInt(BigDecimal.ROUNDED && decis[BigDecimal.DECIMALS] >= "5");
-        }
-        static fromBigInt(bigint) {
-            return Object.assign(Object.create(BigDecimal.prototype), { _n: bigint });
-        }
-        add(num) {
-            return BigDecimal.fromBigInt(this._n + new BigDecimal(num)._n);
-        }
-        subtract(num) {
-            return BigDecimal.fromBigInt(this._n - new BigDecimal(num)._n);
-        }
-        static _divRound(dividend, divisor) {
-            return BigDecimal.fromBigInt(dividend / divisor 
-                + (BigDecimal.ROUNDED ? dividend  * 2n / divisor % 2n : 0n));
-        }
-        multiply(num) {
-            return BigDecimal._divRound(this._n * new BigDecimal(num)._n, BigDecimal.SHIFT);
-        }
-        divide(num) {
-            return BigDecimal._divRound(this._n * BigDecimal.SHIFT, new BigDecimal(num)._n);
-        }
-        toString() {
-            const s = this._n.toString().padStart(BigDecimal.DECIMALS+1, "0");
-            const decimals = s.slice(-BigDecimal.DECIMALS).replace(/\.?0+$/, "")
-            return s.slice(0, -BigDecimal.DECIMALS) + (decimals ? ".":"") + decimals;
-        }
-    }
-});

package/templates/keywords/calc/frontend/js/customizations2.__MERGE__.js

@@ -1 +0,0 @@
-import("./cob/_calc.js");