cob-cli 2.25.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/frontend/formatList/currency/package.json

@@ -1,3 +0,0 @@
-{
-  "version": "1.0.0"
-}

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,78 +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) {
-    // 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");
-    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/audit/package.json

@@ -1,3 +0,0 @@
-{
-  "version": "1.1.12"
-}

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

@@ -1,151 +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) {
-    // 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");	
-    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");

package/templates/keywords/calc/package.json

@@ -1,3 +0,0 @@
-{
-  "version": "1.0.11"
-}

package/templates/keywords/image/frontend/js/cob/_image.js

@@ -1,30 +0,0 @@
-//----------------- $image  ------------------------
-cob.custom.customize.push(function (core, utils, ui) {
-  const matcher = /[$]image(.add|.replace)?(\(.+\))?/;
-
-  core.customizeAllInstances((instance, presenter) => {
-    if (instance.isNew() || presenter.isGroupEdit()) return;
-
-    let imagesFPs = presenter.findFieldPs((fp) => matcher.exec( fp.field.fieldDefinition.description ) );
-    imagesFPs.forEach((fp) => {
-      let args = fp.field.fieldDefinition.description.match(matcher);
-      let replaceFlag = (args && args[1] && args[1] == ".replace") || false;
-      let width = (args && args[2]) || "";
-      debugger;
-      let $image = $(
-        '<div style="width:100%;text-align:center">' +
-          "<img " +
-          (width ? 'style="width:' + width + 'px" ' : "") +
-          'src="' +
-          (fp.field.fieldDefinition.description.match(/[$]file/)
-            ? $(fp.content()[0]).find(".link-container a")[0].href
-            : fp.field.htmlEncodedValue) +
-          '">' +
-          "</img>" +
-          "</div>"
-      );
-      fp.content()[0].append($image[0]);
-      fp.content()[0].children[0].style.display = replaceFlag ? "none" : "";
-    });
-  });
-});

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

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

package/templates/keywords/image/package.json

@@ -1,3 +0,0 @@
-{
-  "version": "1.0.0"
-}