@cronapp/precise-calculations 1.0.0-SNAPSHOT.202407241725

package/cronapp.json

@@ -0,0 +1,24 @@
+{
+  "postUpdate": {
+    "ionic": {
+      "includes": [
+        {
+          "file": "index.html",
+          "script": "node_modules/@cronapp/precise-calculations/precise.calculations.cronapi.js",
+          "type": "script"
+        }
+      ],
+      "cordova": []
+    },
+    "angularJs": {
+      "includes": [
+        {
+          "file": "index.html",
+          "script": "node_modules/@cronapp/precise-calculations/precise.calculations.cronapi.js",
+          "type": "script",
+          "layers": ["web"]
+        }
+      ]
+    }
+  }
+}

package/i18n/locale_en_us.json

@@ -0,0 +1,72 @@
+{
+  "calculateExpression": "Calculate Expression",
+  "calculateExpressionDescription": "Function to calculate a precise mathematical expression",
+  "value1Description": "First value",
+  "operationDescription": "Operation",
+  "value2Description": "Second value",
+  "calculateMathOperation": "Calculate Math Operation",
+  "calculateMathOperationDescription": "Function to calculate a specific math operation",
+  "valueDescription": "Value",
+  "calculateTrigOperation": "Calculate Trig Operation",
+  "calculateTrigOperationDescription": "Function to calculate a specific trigonometric operation",
+  "getConstant": "Get Constant",
+  "getConstantDescription": "Function to get a mathematical constant",
+  "constantDescription": "Constant",
+  "checkProperty": "Check Property",
+  "checkPropertyDescription": "Function to check a number's property",
+  "roundNumber": "Round Number",
+  "roundNumberDescription": "Function to round a number",
+  "generateRandomFraction": "Generate Random Fraction",
+  "generateRandomFractionDescription": "Function to generate a random fraction",
+  "calculateListOperation": "Calculate List Operation",
+  "calculateListOperationDescription": "Function to calculate an operation on a list of numbers",
+  "listDescription": "List of numbers",
+  "calculateModulo": "Calculate Modulo",
+  "calculateModuloDescription": "Function to calculate the remainder of a division",
+  "dividendDescription": "Dividend",
+  "divisorDescription": "Divisor",
+  "generateRandom": "Generate Random Number",
+  "generateRandomDescription": "Function to generate a random number within a range",
+  "minValueDescription": "Minimum value",
+  "maxValueDescription": "Maximum value",
+  "restrictNumber": "Restrict Number",
+  "restrictNumberDescription": "Function to restrict a number within a range",
+  "Addition": "Addition",
+  "Subtraction": "Subtraction",
+  "Multiplication": "Multiplication",
+  "Division": "Division",
+  "Exponentiation": "Exponentiation",
+  "Square root": "Square root",
+  "Absolute value": "Absolute value",
+  "Negative": "Negative",
+  "Natural logarithm": "Natural logarithm",
+  "Logarithm base 10": "Logarithm base 10",
+  "Exponential": "Exponential",
+  "Power of 10": "Power of 10",
+  "Sine": "Sine",
+  "Cosine": "Cosine",
+  "Tangent": "Tangent",
+  "Arc sine": "Arc sine",
+  "Arc cosine": "Arc cosine",
+  "Arc tangent": "Arc tangent",
+  "Pi": "Pi",
+  "Euler": "Euler",
+  "Phi": "Phi",
+  "Square root of 2": "Square root of 2",
+  "Square root of 1/2": "Square root of 1/2",
+  "Even": "Even",
+  "Odd": "Odd",
+  "Integer": "Integer",
+  "Positive": "Positive",
+  "Negative": "Negative",
+  "Round up": "Round up",
+  "Round down": "Round down",
+  "Sum": "Sum",
+  "Minimum value": "Minimum value",
+  "Maximum value": "Maximum value",
+  "Mean": "Mean",
+  "Median": "Median",
+  "Mode": "Mode",
+  "Standard deviation": "Standard deviation",
+  "Random item": "Random item",
+}

package/i18n/locale_pt_br.json

@@ -0,0 +1,72 @@
+{
+  "calculateExpression": "Calcular Expressão",
+  "calculateExpressionDescription": "Função para calcular uma expressão matemática precisa",
+  "value1Description": "Primeiro valor",
+  "operationDescription": "Operação",
+  "value2Description": "Segundo valor",
+  "calculateMathOperation": "Calcular Operação Matemática",
+  "calculateMathOperationDescription": "Função para calcular uma operação matemática específica",
+  "valueDescription": "Valor",
+  "calculateTrigOperation": "Calcular Operação Trigonométrica",
+  "calculateTrigOperationDescription": "Função para calcular uma operação trigonométrica específica",
+  "getConstant": "Obter Constante",
+  "getConstantDescription": "Função para obter uma constante matemática",
+  "constantDescription": "Constante",
+  "checkProperty": "Verificar Propriedade",
+  "checkPropertyDescription": "Função para verificar uma propriedade de um número",
+  "roundNumber": "Arredondar Número",
+  "roundNumberDescription": "Função para arredondar um número",
+  "generateRandomFraction": "Gerar Fração Aleatória",
+  "generateRandomFractionDescription": "Função para gerar uma fração aleatória",
+  "calculateListOperation": "Calcular Operação em Lista",
+  "calculateListOperationDescription": "Função para calcular uma operação em uma lista de números",
+  "listDescription": "Lista de números",
+  "calculateModulo": "Calcular Módulo",
+  "calculateModuloDescription": "Função para calcular o resto da divisão",
+  "dividendDescription": "Dividendo",
+  "divisorDescription": "Divisor",
+  "generateRandom": "Gerar Número Aleatório",
+  "generateRandomDescription": "Função para gerar um número aleatório dentro de um intervalo",
+  "minValueDescription": "Valor mínimo",
+  "maxValueDescription": "Valor máximo",
+  "restrictNumber": "Restringir Número",
+  "restrictNumberDescription": "Função para restringir um número dentro de um intervalo",
+  "Addition": "Adição",
+  "Subtraction": "Subtração",
+  "Multiplication": "Multiplicação",
+  "Division": "Divisão",
+  "Exponentiation": "Exponenciação",
+  "Square root": "Raiz quadrada",
+  "Absolute value": "Valor absoluto",
+  "Negative": "Negativo",
+  "Natural logarithm": "Logaritmo natural",
+  "Logarithm base 10": "Logaritmo base 10",
+  "Exponential": "Exponencial",
+  "Power of 10": "Potência de 10",
+  "Sine": "Seno",
+  "Cosine": "Cosseno",
+  "Tangent": "Tangente",
+  "Arc sine": "Arco seno",
+  "Arc cosine": "Arco cosseno",
+  "Arc tangent": "Arco tangente",
+  "Pi": "Pi",
+  "Euler": "Euler",
+  "Phi": "Phi",
+  "Square root of 2": "Raiz quadrada de 2",
+  "Square root of 1/2": "Raiz quadrada de 1/2",
+  "Even": "Par",
+  "Odd": "Ímpar",
+  "Integer": "Inteiro",
+  "Positive": "Positivo",
+  "Negative": "Negativo",
+  "Round up": "Arredondar para cima",
+  "Round down": "Arredondar para baixo",
+  "Sum": "Soma",
+  "Minimum value": "Menor valor",
+  "Maximum value": "Maior valor",
+  "Mean": "Média",
+  "Median": "Mediana",
+  "Mode": "Moda",
+  "Standard deviation": "Desvio padrão",
+  "Random item": "Item aleatório"
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@cronapp/precise-calculations",
+  "version": "1.0.0-SNAPSHOT.202407241725",
+  "description": "Cronapp Precise Calculations Plugin",
+  "keywords": [
+    "cronapp",
+    "precise",
+    "calculations",
+    "plugin",
+    "mobile",
+    "web",
+    "mathjs"
+  ],
+  "author": "Cronapp Studio",
+  "license": "ISC",
+  "dependencies": {
+    "mathjs": "^10.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/precise.calculations.cronapi.js

@@ -0,0 +1,410 @@
+(function() {
+  'use strict';
+
+  this.cronapi = this.cronapi || {};
+
+  /**
+   * @categoryName Precise Calculations
+   */
+  this.cronapi.precise = this.cronapi.precise || {};
+
+  /**
+   * @type function
+   * @name {{calculateExpression}}
+   * @nameTags calcular, expressão, operação matemática
+   * @description {{calculateExpressionDescription}}
+   * @param {ObjectType.LONG} value1 {{value1Description}}
+   * @param {ObjectType.STRING} operation {{operationDescription}} @blockType util_dropdown @keys add|subtract|multiply|divide|pow @values Adição|Subtração|Multiplicação|Divisão|Exponenciação
+   * @param {ObjectType.LONG} value2 {{value2Description}}
+   * @returns {ObjectType.STRING}
+   */
+  this.cronapi.precise.calculateExpressionCalcula = function(value1, operation, value2) {
+    let result;
+    try {
+      const num1 = math.bignumber(value1);
+      const num2 = math.bignumber(value2);
+
+      switch (operation) {
+        case 'add':
+          result = math.add(num1, num2);
+          break;
+        case 'subtract':
+          result = math.subtract(num1, num2);
+          break;
+        case 'multiply':
+          result = math.multiply(num1, num2);
+          break;
+        case 'divide':
+          result = math.divide(num1, num2);
+          break;
+        case 'pow':
+          result = math.pow(num1, num2);
+          break;
+        default:
+          return 'Operação inválida';
+      }
+
+    } catch (e) {
+      console.error('Erro ao realizar a operação:', e);
+      return "Erro na expressão";
+    }
+
+    return `Resultado: ${result}`;
+  }
+
+  /**
+   * @type function
+   * @name {{calculateMathOperation}}
+   * @nameTags calcular, operação matemática, expressão
+   * @description {{calculateMathOperationDescription}}
+   * @param {ObjectType.STRING} operation {{operationDescription}} @blockType util_dropdown @keys sqrt|abs|neg|ln|log10|exp|pow10 @values Raiz quadrada|Valor absoluto|Negativo|Logaritmo natural|Logaritmo base 10|Exponencial|Potência de 10
+   * @param {ObjectType.LONG} value {{valueDescription}} @default 0
+   * @returns {ObjectType.LONG}
+   */
+  this.cronapi.precise.calculateMathOperation = function(operation, value) {
+    let result;
+    try {
+      switch (operation) {
+        case 'sqrt':
+          result = math.sqrt(math.bignumber(value));
+          break;
+        case 'abs':
+          result = math.abs(math.bignumber(value));
+          break;
+        case 'neg':
+          result = math.neg(math.bignumber(value));
+          break;
+        case 'ln':
+          result = math.log(math.bignumber(value));
+          break;
+        case 'log10':
+          result = math.log10(math.bignumber(value));
+          break;
+        case 'exp':
+          result = math.exp(math.bignumber(value));
+          break;
+        case 'pow10':
+          result = math.pow(10, math.bignumber(value));
+          break;
+        default:
+          return 'Operação inválida';
+      }
+    } catch (e) {
+      console.error('Erro ao realizar a operação matemática:', e);
+      return "Erro na expressão";
+    }
+
+    return Number(result);
+  }
+
+  /**
+   * @type function
+   * @name {{calculateTrigOperation}}
+   * @nameTags trigonometria, operação trigonométrica, seno, cosseno, tangente
+   * @description {{calculateTrigOperationDescription}}
+   * @param {ObjectType.STRING} operation {{operationDescription}} @blockType util_dropdown @keys sin|cos|tan|asin|acos|atan @values Seno|Cosseno|Tangente|Arco seno|Arco cosseno|Arco tangente
+   * @param {ObjectType.LONG} value {{valueDescription}} @default 0
+   * @returns {ObjectType.LONG}
+   */
+  this.cronapi.precise.calculateTrigOperation = function(operation, value) {
+    let result;
+    try {
+      switch (operation) {
+        case 'sin':
+          result = math.sin(math.unit(math.bignumber(value), 'deg'));
+          break;
+        case 'cos':
+          result = math.cos(math.unit(math.bignumber(value), 'deg'));
+          break;
+        case 'tan':
+          result = math.tan(math.unit(math.bignumber(value), 'deg'));
+          break;
+        case 'asin':
+          result = math.asin(math.bignumber(value));
+          break;
+        case 'acos':
+          result = math.acos(math.bignumber(value));
+          break;
+        case 'atan':
+          result = math.atan(math.bignumber(value));
+          break;
+        default:
+          return 'Operação inválida';
+      }
+    } catch (e) {
+      console.error('Erro ao realizar a operação trigonométrica:', e);
+      return "Erro na expressão";
+    }
+
+    return Number(result);
+  }
+
+  /**
+   * @type function
+   * @name {{getConstant}}
+   * @nameTags constante, constante matemática
+   * @description {{getConstantDescription}}
+   * @param {ObjectType.STRING} constant {{constantDescription}} @blockType util_dropdown @keys pi|e|phi|sqrt2|sqrt1_2 @values Pi|Euler|Phi|Raiz quadrada de 2|Raiz quadrada de 1/2
+   * @returns {ObjectType.LONG}
+   */
+  this.cronapi.precise.getConstant = function(constant) {
+    let result;
+    try {
+      switch (constant) {
+        case 'pi':
+          result = math.pi;
+          break;
+        case 'e':
+          result = math.e;
+          break;
+        case 'phi':
+          result = (1 + math.sqrt(5)) / 2;
+          break;
+        case 'sqrt2':
+          result = math.sqrt(2);
+          break;
+        case 'sqrt1_2':
+          result = math.sqrt(1 / 2);
+          break;
+        default:
+          return 'Operação inválida';
+      }
+    } catch (e) {
+      console.error('Erro ao obter a constante matemática:', e);
+      return "Erro na expressão";
+    }
+    
+    return Number(result);
+  }
+
+    /**
+   * @type function
+   * @name {{checkProperty}}
+   * @nameTags verificar propriedade, número, propriedade matemática
+   * @description {{checkPropertyDescription}}
+   * @param {ObjectType.LONG} value {{valueDescription}}
+   * @param {ObjectType.STRING} operation {{operationDescription}} @blockType util_dropdown @keys isEven|isOdd|isInteger|isPositive|isNegative @values Par|Ímpar|Inteiro|Positivo|Negativo
+   * @returns {ObjectType.BOOLEAN}
+   */
+  this.cronapi.precise.checkProperty = function(value, operation) {
+    let result;
+    try {
+      switch (operation) {
+        case 'isEven':
+          result = math.mod(math.bignumber(value), 2).equals(0);
+          break;
+        case 'isOdd':
+          result = !math.mod(math.bignumber(value), 2).equals(0);
+          break;
+        case 'isInteger':
+          result = math.isInteger(math.bignumber(value));
+          break;
+        case 'isPositive':
+          result = math.bignumber(value).isPositive();
+          break;
+        case 'isNegative':
+          result = math.bignumber(value).isNegative();
+          break;
+        default:
+          return 'Operação inválida';
+      }
+    } catch (e) {
+      console.error('Erro ao verificar a propriedade:', e);
+      return false;
+    }
+
+    return result;
+  }
+
+  /**
+   * @type function
+   * @name {{roundNumber}}
+   * @nameTags arredondar, ceil, floor
+   * @description {{roundNumberDescription}}
+   * @param {ObjectType.STRING} operation {{operationDescription}} @blockType util_dropdown @keys ceil|floor @values Arredondar para cima|Arredondar para baixo
+   * @param {ObjectType.LONG} value {{valueDescription}}
+   * @returns {ObjectType.STRING}
+   */
+  this.cronapi.precise.roundNumber = function(operation, value) {
+    let result;
+    try {
+      const num = math.bignumber(value);
+
+      switch (operation) {
+        case 'ceil':
+          result = math.ceil(num);
+          break;
+        case 'floor':
+          result = math.floor(num);
+          break;
+        default:
+          return 'Operação inválida';
+      }
+
+    } catch (e) {
+      console.error('Erro ao realizar a operação de arredondamento:', e);
+      return "Erro na expressão";
+    }
+
+    return `Resultado: ${result}`;
+  }
+
+  /**
+   * @type function
+   * @name generateRandomFraction
+   * @description Gera uma fração aleatória
+   * @nameTags random | fraction | generate
+   * @returns {ObjectType.STRING}
+   */
+  this.cronapi.precise.generateRandomFraction = function() {
+    if (typeof math === 'undefined') {
+      return 'Erro na lib';
+    }
+    const result = math.bignumber(Math.random());
+    return `Resultado: ${result}`;
+  };
+
+  /**
+   * @type function
+   * @name {{calculateListOperation}}
+   * @nameTags calcular, operação em lista, soma a lista, menor valor, maior valor, média, mediana, moda, desvio padrão, item aleatório
+   * @description {{calculateListOperationDescription}}
+   * @param {ObjectType.STRING} operation {{operationDescription}} @blockType util_dropdown @keys sum|min|max|mean|median|mode|std|random @values Soma|Menor valor|Maior valor|Média|Mediana|Moda|Desvio padrão|Item aleatório
+   * @param {ObjectType.STRING} list {{listDescription}} @default 0
+   * @returns {ObjectType.STRING}
+   */
+  this.cronapi.precise.calculateListOperation = function(operation, list) {
+    let result;
+    try {
+      const numbers = list.split(',').map(num => math.bignumber(num.trim()));
+
+      switch (operation) {
+        case 'sum':
+          result = math.sum(numbers);
+          break;
+        case 'min':
+          result = math.min(numbers);
+          break;
+        case 'max':
+          result = math.max(numbers);
+          break;
+        case 'mean':
+          result = math.mean(numbers);
+          break;
+        case 'median':
+          result = math.median(numbers);
+          break;
+        case 'mode':
+          result = math.mode(numbers);
+          break;
+        case 'std':
+          result = math.std(numbers);
+          break;
+        case 'random':
+          result = numbers[math.floor(Math.random() * numbers.length)];
+          break;
+        default:
+          return 'Operação inválida';
+      }
+
+    } catch (e) {
+      console.error('Erro ao realizar a operação em lista:', e);
+      return "Erro na expressão";
+    }
+
+    return `Resultado: ${result}`;
+  }
+
+  /**
+   * @type function
+   * @name {{calculateModulo}}
+   * @nameTags calcular, resto, divisão, módulo
+   * @description {{calculateModuloDescription}}
+   * @param {ObjectType.LONG} dividend {{dividendDescription}}
+   * @param {ObjectType.STRING} operation {{operationDescription}} @blockType util_dropdown @keys mod @values ÷
+   * @param {ObjectType.LONG} divisor {{divisorDescription}}
+   * @returns {ObjectType.STRING}
+   */
+  this.cronapi.precise.calculateModulo = function(dividend, operation, divisor) {
+    let result;
+    try {
+      const num1 = math.bignumber(dividend);
+      const num2 = math.bignumber(divisor);
+
+      switch (operation) {
+        case 'mod':
+          result = math.mod(num1, num2);
+          break;
+        default:
+          return 'Operação inválida';
+      }
+
+    } catch (e) {
+      console.error('Erro ao calcular o resto da divisão:', e);
+      return "Erro na expressão";
+    }
+
+    return `Resultado: ${result}`;
+  }
+
+  /**
+   * @type function
+   * @name {{generateRandom}}
+   * @nameTags aleatório, número, random
+   * @description {{generateRandomDescription}}
+   * @param {ObjectType.LONG} minValue {{minValueDescription}}
+   * @param {ObjectType.LONG} maxValue {{maxValueDescription}}
+   * @returns {ObjectType.STRING}
+   */
+  this.cronapi.precise.generateRandom = function(minValue, maxValue) {
+    let result;
+    try {
+      const min = math.bignumber(minValue);
+      const max = math.bignumber(maxValue);
+
+      if (math.largerEq(min, max)) {
+        throw new Error("O valor mínimo deve ser menor que o valor máximo.");
+      }
+
+      const randomValue = math.bignumber(Math.random());
+      const range = math.subtract(max, min);
+      const scaledRandomValue = math.multiply(randomValue, range);
+      result = math.floor(math.add(min, scaledRandomValue));
+
+    } catch (e) {
+      console.error('Erro ao gerar número aleatório:', e);
+      return "Erro na expressão";
+    }
+
+    return `Resultado: ${result}`;
+  }
+
+  /**
+   * @type function
+   * @name {{restrictNumber}}
+   * @nameTags restringir, valor, limite
+   * @description {{restrictNumberDescription}}
+   * @param {ObjectType.LONG} value {{valueDescription}} @default 50
+   * @param {ObjectType.LONG} minValue {{minValueDescription}} @default 1
+   * @param {ObjectType.LONG} maxValue {{maxValueDescription}} @default 100
+   * @returns {ObjectType.STRING}
+   */
+  this.cronapi.precise.restrictNumber = function(value, minValue, maxValue) {
+    let result;
+    try {
+      const num = math.bignumber(value);
+      const min = math.bignumber(minValue);
+      const max = math.bignumber(maxValue);
+
+      result = math.max(math.min(num, max), min);
+
+    } catch (e) {
+      console.error('Erro ao restringir número:', e);
+      return "Erro na expressão";
+    }
+
+    return `Resultado: ${result}`;
+  }
+
+}).bind(window)();
+