y-ary 0.0.2

package/dist/index.d.cts

@@ -0,0 +1,247 @@
+/**
+ * Interprets a mathematical formula by replacing variables with their values
+ * @param formula - Mathematical formula as a string (e.g., 'x/1 + y')
+ * @param where - Object mapping variable names to their numeric values (e.g., {x: 4, y: 6})
+ * @returns The evaluated result of the formula
+ */
+declare const formulaInterpreter: (formula: string, where: {
+    [key: string]: number;
+}) => number;
+
+/**
+ * Generates an array or matrix by randomly selecting numbers from a bank with occurrence limits.
+ *
+ * @param bankNums - Object where keys are the numbers to use and values are the maximum
+ *                   number of times each number can appear in the array.
+ *                   Example: { 1: 3, 2: 3, 3: 3 } means number 1 can appear up to 3 times,
+ *                   number 2 can appear up to 3 times, etc.
+ *
+ * @param dims - Array dimensions:
+ *   - [length]: Creates a 1D array with the specified length
+ *   - [rows, cols]: Creates a 2D array (matrix) with the specified rows and columns
+ *
+ * @param extraRules - Optional validation callback that receives:
+ *   - candidateNum: The number being considered for addition
+ *   - currentArray: The flattened array built so far (for 2D arrays, this is all elements)
+ *   Returns true to allow the number, false to reject it and try another.
+ *
+ * @returns A 1D array or 2D array (matrix) of numbers randomly selected from bankNums,
+ *          respecting occurrence limits and any extra validation rules.
+ *
+ * @example
+ * // Generate 1D array of length 5
+ * const result1D = arrayWithBankNums(
+ *   { 1: 3, 2: 3, 3: 3, 4: 3, 5: 3, 6: 3, 7: 3, 8: 3, 9: 3, 10: 3 },
+ *   [5]
+ * );
+ * // Possible result: [3, 7, 1, 9, 2]
+ *
+ * @example
+ * // Generate 2D array (matrix) of 3 rows x 4 columns
+ * const result2D = arrayWithBankNums(
+ *   { 1: 3, 2: 3, 3: 3, 4: 3, 5: 3, 6: 3 },
+ *   [3, 4]
+ * );
+ * // Possible result: [[1, 3, 2, 5], [4, 1, 6, 3], [2, 5, 4, 6]]
+ *
+ * @example
+ * // With extraRules: only allow even numbers
+ * const result = arrayWithBankNums(
+ *   { 1: 3, 2: 3, 3: 3, 4: 3, 5: 3, 6: 3 },
+ *   [4],
+ *   (num, arr) => num % 2 === 0
+ * );
+ * // Possible result: [2, 4, 6, 2]
+ */
+declare const arrayWithBankNums: (bankNums: {
+    [n: number]: number;
+}, dims: number[], extraRules?: (candidateNum: number, currentArray: number[]) => boolean) => number[] | number[][];
+
+/**
+ * Array Rules - Colección de funciones de validación para usar con arrayWithBankNums
+ *
+ * Estas funciones pueden ser usadas como el parámetro `extraRules` en arrayWithBankNums
+ * para aplicar restricciones adicionales durante la generación del array.
+ */
+/**
+ * Type definition for array rule functions
+ */
+type ArrayRule = (candidateNum: number, currentArray: number[]) => boolean;
+/**
+ * Solo permite números pares
+ * @example arrayWithBankNums(bankNums, [5], onlyEven)
+ */
+declare const onlyEven: ArrayRule;
+/**
+ * Solo permite números impares
+ * @example arrayWithBankNums(bankNums, [5], onlyOdd)
+ */
+declare const onlyOdd: ArrayRule;
+/**
+ * Crea una regla que solo permite números dentro de un rango específico
+ * @param min - Valor mínimo (inclusivo)
+ * @param max - Valor máximo (inclusivo)
+ * @example arrayWithBankNums(bankNums, [5], inRange(1, 5))
+ */
+declare const inRange: (min: number, max: number) => ArrayRule;
+/**
+ * Crea una regla que excluye números dentro de un rango específico
+ * @param min - Valor mínimo a excluir (inclusivo)
+ * @param max - Valor máximo a excluir (inclusivo)
+ * @example arrayWithBankNums(bankNums, [5], notInRange(3, 7))
+ */
+declare const notInRange: (min: number, max: number) => ArrayRule;
+/**
+ * No permite números consecutivos repetidos
+ * @example arrayWithBankNums(bankNums, [5], noConsecutiveRepeats)
+ */
+declare const noConsecutiveRepeats: ArrayRule;
+/**
+ * No permite que un número aparezca más de N veces en el array
+ * @param maxCount - Número máximo de veces que puede aparecer
+ * @example arrayWithBankNums(bankNums, [10], maxOccurrences(2))
+ */
+declare const maxOccurrences: (maxCount: number) => ArrayRule;
+/**
+ * No permite duplicados en el array (cada número solo puede aparecer una vez)
+ * @example arrayWithBankNums(bankNums, [5], noDuplicates)
+ */
+declare const noDuplicates: ArrayRule;
+/**
+ * No permite que el mismo número aparezca en las últimas N posiciones
+ * @param positions - Número de posiciones a verificar
+ * @example arrayWithBankNums(bankNums, [10], noRepeatInLast(3))
+ */
+declare const noRepeatInLast: (positions: number) => ArrayRule;
+/**
+ * Solo permite números que mantengan la suma total por debajo de un límite
+ * @param maxSum - Suma máxima permitida
+ * @example arrayWithBankNums(bankNums, [5], sumLessThan(20))
+ */
+declare const sumLessThan: (maxSum: number) => ArrayRule;
+/**
+ * Solo permite números que mantengan la suma total por encima de un límite
+ * @param minSum - Suma mínima requerida
+ * @example arrayWithBankNums(bankNums, [5], sumGreaterThan(10))
+ */
+declare const sumGreaterThan: (minSum: number) => ArrayRule;
+/**
+ * Solo permite números que mantengan el promedio dentro de un rango
+ * @param min - Promedio mínimo
+ * @param max - Promedio máximo
+ * @example arrayWithBankNums(bankNums, [5], averageInRange(3, 7))
+ */
+declare const averageInRange: (min: number, max: number) => ArrayRule;
+/**
+ * Solo permite números que sean mayores que el último número en el array (orden ascendente)
+ * @example arrayWithBankNums(bankNums, [5], ascending)
+ */
+declare const ascending: ArrayRule;
+/**
+ * Solo permite números que sean menores que el último número en el array (orden descendente)
+ * @example arrayWithBankNums(bankNums, [5], descending)
+ */
+declare const descending: ArrayRule;
+/**
+ * Solo permite números que sean diferentes del último número (no estrictamente ascendente/descendente)
+ * @example arrayWithBankNums(bankNums, [5], different)
+ */
+declare const different: ArrayRule;
+/**
+ * Alterna entre números pares e impares
+ * @example arrayWithBankNums(bankNums, [6], alternateEvenOdd)
+ */
+declare const alternateEvenOdd: ArrayRule;
+/**
+ * Solo permite números divisibles por un divisor específico
+ * @param divisor - El divisor
+ * @example arrayWithBankNums(bankNums, [5], divisibleBy(3))
+ */
+declare const divisibleBy: (divisor: number) => ArrayRule;
+/**
+ * Solo permite números que NO sean divisibles por un divisor específico
+ * @param divisor - El divisor
+ * @example arrayWithBankNums(bankNums, [5], notDivisibleBy(5))
+ */
+declare const notDivisibleBy: (divisor: number) => ArrayRule;
+/**
+ * Aplica diferentes reglas según la posición en el array
+ * @param rules - Objeto que mapea índices a reglas
+ * @example arrayWithBankNums(bankNums, [5], byPosition({ 0: onlyEven, 1: onlyOdd }))
+ */
+declare const byPosition: (rules: {
+    [index: number]: ArrayRule;
+}) => ArrayRule;
+/**
+ * Aplica una regla solo en posiciones pares (0, 2, 4, ...)
+ * @param rule - La regla a aplicar
+ * @example arrayWithBankNums(bankNums, [6], onEvenPositions(onlyEven))
+ */
+declare const onEvenPositions: (rule: ArrayRule) => ArrayRule;
+/**
+ * Aplica una regla solo en posiciones impares (1, 3, 5, ...)
+ * @param rule - La regla a aplicar
+ * @example arrayWithBankNums(bankNums, [6], onOddPositions(onlyOdd))
+ */
+declare const onOddPositions: (rule: ArrayRule) => ArrayRule;
+/**
+ * Combina múltiples reglas con AND (todas deben cumplirse)
+ * @param rules - Array de reglas a combinar
+ * @example arrayWithBankNums(bankNums, [5], and([onlyEven, inRange(2, 8)]))
+ */
+declare const and: (rules: ArrayRule[]) => ArrayRule;
+/**
+ * Combina múltiples reglas con OR (al menos una debe cumplirse)
+ * @param rules - Array de reglas a combinar
+ * @example arrayWithBankNums(bankNums, [5], or([onlyEven, divisibleBy(3)]))
+ */
+declare const or: (rules: ArrayRule[]) => ArrayRule;
+/**
+ * Invierte una regla (NOT)
+ * @param rule - La regla a invertir
+ * @example arrayWithBankNums(bankNums, [5], not(onlyEven)) // Solo impares
+ */
+declare const not: (rule: ArrayRule) => ArrayRule;
+/**
+ * Solo permite números primos
+ * @example arrayWithBankNums(bankNums, [5], onlyPrimes)
+ */
+declare const onlyPrimes: ArrayRule;
+/**
+ * Solo permite números que sean cuadrados perfectos
+ * @example arrayWithBankNums(bankNums, [5], onlySquares)
+ */
+declare const onlySquares: ArrayRule;
+/**
+ * Asegura que la diferencia entre números consecutivos no exceda un límite
+ * @param maxDiff - Diferencia máxima permitida
+ * @example arrayWithBankNums(bankNums, [5], maxDifference(3))
+ */
+declare const maxDifference: (maxDiff: number) => ArrayRule;
+/**
+ * Asegura que la diferencia entre números consecutivos sea al menos un mínimo
+ * @param minDiff - Diferencia mínima requerida
+ * @example arrayWithBankNums(bankNums, [5], minDifference(2))
+ */
+declare const minDifference: (minDiff: number) => ArrayRule;
+/**
+ * Mantiene un balance entre números pares e impares
+ * @param maxImbalance - Diferencia máxima permitida entre cantidad de pares e impares
+ * @example arrayWithBankNums(bankNums, [10], balanceEvenOdd(2))
+ */
+declare const balanceEvenOdd: (maxImbalance?: number) => ArrayRule;
+/**
+ * Solo permite números en posiciones específicas del array
+ * @param allowedPositions - Array de posiciones permitidas (0-indexed)
+ * @param value - El valor que solo puede aparecer en esas posiciones
+ * @example arrayWithBankNums(bankNums, [5], valueAtPositions([0, 2, 4], 7))
+ */
+declare const valueAtPositions: (allowedPositions: number[], value: number) => ArrayRule;
+
+/**
+ * Y-ary package entry point
+ * Export your public API here
+ */
+declare function hello(name: string): string;
+
+export { type ArrayRule, alternateEvenOdd, and, arrayWithBankNums, ascending, averageInRange, balanceEvenOdd, byPosition, descending, different, divisibleBy, formulaInterpreter, hello, inRange, maxDifference, maxOccurrences, minDifference, noConsecutiveRepeats, noDuplicates, noRepeatInLast, not, notDivisibleBy, notInRange, onEvenPositions, onOddPositions, onlyEven, onlyOdd, onlyPrimes, onlySquares, or, sumGreaterThan, sumLessThan, valueAtPositions };

package/dist/index.d.ts

@@ -0,0 +1,247 @@
+/**
+ * Interprets a mathematical formula by replacing variables with their values
+ * @param formula - Mathematical formula as a string (e.g., 'x/1 + y')
+ * @param where - Object mapping variable names to their numeric values (e.g., {x: 4, y: 6})
+ * @returns The evaluated result of the formula
+ */
+declare const formulaInterpreter: (formula: string, where: {
+    [key: string]: number;
+}) => number;
+
+/**
+ * Generates an array or matrix by randomly selecting numbers from a bank with occurrence limits.
+ *
+ * @param bankNums - Object where keys are the numbers to use and values are the maximum
+ *                   number of times each number can appear in the array.
+ *                   Example: { 1: 3, 2: 3, 3: 3 } means number 1 can appear up to 3 times,
+ *                   number 2 can appear up to 3 times, etc.
+ *
+ * @param dims - Array dimensions:
+ *   - [length]: Creates a 1D array with the specified length
+ *   - [rows, cols]: Creates a 2D array (matrix) with the specified rows and columns
+ *
+ * @param extraRules - Optional validation callback that receives:
+ *   - candidateNum: The number being considered for addition
+ *   - currentArray: The flattened array built so far (for 2D arrays, this is all elements)
+ *   Returns true to allow the number, false to reject it and try another.
+ *
+ * @returns A 1D array or 2D array (matrix) of numbers randomly selected from bankNums,
+ *          respecting occurrence limits and any extra validation rules.
+ *
+ * @example
+ * // Generate 1D array of length 5
+ * const result1D = arrayWithBankNums(
+ *   { 1: 3, 2: 3, 3: 3, 4: 3, 5: 3, 6: 3, 7: 3, 8: 3, 9: 3, 10: 3 },
+ *   [5]
+ * );
+ * // Possible result: [3, 7, 1, 9, 2]
+ *
+ * @example
+ * // Generate 2D array (matrix) of 3 rows x 4 columns
+ * const result2D = arrayWithBankNums(
+ *   { 1: 3, 2: 3, 3: 3, 4: 3, 5: 3, 6: 3 },
+ *   [3, 4]
+ * );
+ * // Possible result: [[1, 3, 2, 5], [4, 1, 6, 3], [2, 5, 4, 6]]
+ *
+ * @example
+ * // With extraRules: only allow even numbers
+ * const result = arrayWithBankNums(
+ *   { 1: 3, 2: 3, 3: 3, 4: 3, 5: 3, 6: 3 },
+ *   [4],
+ *   (num, arr) => num % 2 === 0
+ * );
+ * // Possible result: [2, 4, 6, 2]
+ */
+declare const arrayWithBankNums: (bankNums: {
+    [n: number]: number;
+}, dims: number[], extraRules?: (candidateNum: number, currentArray: number[]) => boolean) => number[] | number[][];
+
+/**
+ * Array Rules - Colección de funciones de validación para usar con arrayWithBankNums
+ *
+ * Estas funciones pueden ser usadas como el parámetro `extraRules` en arrayWithBankNums
+ * para aplicar restricciones adicionales durante la generación del array.
+ */
+/**
+ * Type definition for array rule functions
+ */
+type ArrayRule = (candidateNum: number, currentArray: number[]) => boolean;
+/**
+ * Solo permite números pares
+ * @example arrayWithBankNums(bankNums, [5], onlyEven)
+ */
+declare const onlyEven: ArrayRule;
+/**
+ * Solo permite números impares
+ * @example arrayWithBankNums(bankNums, [5], onlyOdd)
+ */
+declare const onlyOdd: ArrayRule;
+/**
+ * Crea una regla que solo permite números dentro de un rango específico
+ * @param min - Valor mínimo (inclusivo)
+ * @param max - Valor máximo (inclusivo)
+ * @example arrayWithBankNums(bankNums, [5], inRange(1, 5))
+ */
+declare const inRange: (min: number, max: number) => ArrayRule;
+/**
+ * Crea una regla que excluye números dentro de un rango específico
+ * @param min - Valor mínimo a excluir (inclusivo)
+ * @param max - Valor máximo a excluir (inclusivo)
+ * @example arrayWithBankNums(bankNums, [5], notInRange(3, 7))
+ */
+declare const notInRange: (min: number, max: number) => ArrayRule;
+/**
+ * No permite números consecutivos repetidos
+ * @example arrayWithBankNums(bankNums, [5], noConsecutiveRepeats)
+ */
+declare const noConsecutiveRepeats: ArrayRule;
+/**
+ * No permite que un número aparezca más de N veces en el array
+ * @param maxCount - Número máximo de veces que puede aparecer
+ * @example arrayWithBankNums(bankNums, [10], maxOccurrences(2))
+ */
+declare const maxOccurrences: (maxCount: number) => ArrayRule;
+/**
+ * No permite duplicados en el array (cada número solo puede aparecer una vez)
+ * @example arrayWithBankNums(bankNums, [5], noDuplicates)
+ */
+declare const noDuplicates: ArrayRule;
+/**
+ * No permite que el mismo número aparezca en las últimas N posiciones
+ * @param positions - Número de posiciones a verificar
+ * @example arrayWithBankNums(bankNums, [10], noRepeatInLast(3))
+ */
+declare const noRepeatInLast: (positions: number) => ArrayRule;
+/**
+ * Solo permite números que mantengan la suma total por debajo de un límite
+ * @param maxSum - Suma máxima permitida
+ * @example arrayWithBankNums(bankNums, [5], sumLessThan(20))
+ */
+declare const sumLessThan: (maxSum: number) => ArrayRule;
+/**
+ * Solo permite números que mantengan la suma total por encima de un límite
+ * @param minSum - Suma mínima requerida
+ * @example arrayWithBankNums(bankNums, [5], sumGreaterThan(10))
+ */
+declare const sumGreaterThan: (minSum: number) => ArrayRule;
+/**
+ * Solo permite números que mantengan el promedio dentro de un rango
+ * @param min - Promedio mínimo
+ * @param max - Promedio máximo
+ * @example arrayWithBankNums(bankNums, [5], averageInRange(3, 7))
+ */
+declare const averageInRange: (min: number, max: number) => ArrayRule;
+/**
+ * Solo permite números que sean mayores que el último número en el array (orden ascendente)
+ * @example arrayWithBankNums(bankNums, [5], ascending)
+ */
+declare const ascending: ArrayRule;
+/**
+ * Solo permite números que sean menores que el último número en el array (orden descendente)
+ * @example arrayWithBankNums(bankNums, [5], descending)
+ */
+declare const descending: ArrayRule;
+/**
+ * Solo permite números que sean diferentes del último número (no estrictamente ascendente/descendente)
+ * @example arrayWithBankNums(bankNums, [5], different)
+ */
+declare const different: ArrayRule;
+/**
+ * Alterna entre números pares e impares
+ * @example arrayWithBankNums(bankNums, [6], alternateEvenOdd)
+ */
+declare const alternateEvenOdd: ArrayRule;
+/**
+ * Solo permite números divisibles por un divisor específico
+ * @param divisor - El divisor
+ * @example arrayWithBankNums(bankNums, [5], divisibleBy(3))
+ */
+declare const divisibleBy: (divisor: number) => ArrayRule;
+/**
+ * Solo permite números que NO sean divisibles por un divisor específico
+ * @param divisor - El divisor
+ * @example arrayWithBankNums(bankNums, [5], notDivisibleBy(5))
+ */
+declare const notDivisibleBy: (divisor: number) => ArrayRule;
+/**
+ * Aplica diferentes reglas según la posición en el array
+ * @param rules - Objeto que mapea índices a reglas
+ * @example arrayWithBankNums(bankNums, [5], byPosition({ 0: onlyEven, 1: onlyOdd }))
+ */
+declare const byPosition: (rules: {
+    [index: number]: ArrayRule;
+}) => ArrayRule;
+/**
+ * Aplica una regla solo en posiciones pares (0, 2, 4, ...)
+ * @param rule - La regla a aplicar
+ * @example arrayWithBankNums(bankNums, [6], onEvenPositions(onlyEven))
+ */
+declare const onEvenPositions: (rule: ArrayRule) => ArrayRule;
+/**
+ * Aplica una regla solo en posiciones impares (1, 3, 5, ...)
+ * @param rule - La regla a aplicar
+ * @example arrayWithBankNums(bankNums, [6], onOddPositions(onlyOdd))
+ */
+declare const onOddPositions: (rule: ArrayRule) => ArrayRule;
+/**
+ * Combina múltiples reglas con AND (todas deben cumplirse)
+ * @param rules - Array de reglas a combinar
+ * @example arrayWithBankNums(bankNums, [5], and([onlyEven, inRange(2, 8)]))
+ */
+declare const and: (rules: ArrayRule[]) => ArrayRule;
+/**
+ * Combina múltiples reglas con OR (al menos una debe cumplirse)
+ * @param rules - Array de reglas a combinar
+ * @example arrayWithBankNums(bankNums, [5], or([onlyEven, divisibleBy(3)]))
+ */
+declare const or: (rules: ArrayRule[]) => ArrayRule;
+/**
+ * Invierte una regla (NOT)
+ * @param rule - La regla a invertir
+ * @example arrayWithBankNums(bankNums, [5], not(onlyEven)) // Solo impares
+ */
+declare const not: (rule: ArrayRule) => ArrayRule;
+/**
+ * Solo permite números primos
+ * @example arrayWithBankNums(bankNums, [5], onlyPrimes)
+ */
+declare const onlyPrimes: ArrayRule;
+/**
+ * Solo permite números que sean cuadrados perfectos
+ * @example arrayWithBankNums(bankNums, [5], onlySquares)
+ */
+declare const onlySquares: ArrayRule;
+/**
+ * Asegura que la diferencia entre números consecutivos no exceda un límite
+ * @param maxDiff - Diferencia máxima permitida
+ * @example arrayWithBankNums(bankNums, [5], maxDifference(3))
+ */
+declare const maxDifference: (maxDiff: number) => ArrayRule;
+/**
+ * Asegura que la diferencia entre números consecutivos sea al menos un mínimo
+ * @param minDiff - Diferencia mínima requerida
+ * @example arrayWithBankNums(bankNums, [5], minDifference(2))
+ */
+declare const minDifference: (minDiff: number) => ArrayRule;
+/**
+ * Mantiene un balance entre números pares e impares
+ * @param maxImbalance - Diferencia máxima permitida entre cantidad de pares e impares
+ * @example arrayWithBankNums(bankNums, [10], balanceEvenOdd(2))
+ */
+declare const balanceEvenOdd: (maxImbalance?: number) => ArrayRule;
+/**
+ * Solo permite números en posiciones específicas del array
+ * @param allowedPositions - Array de posiciones permitidas (0-indexed)
+ * @param value - El valor que solo puede aparecer en esas posiciones
+ * @example arrayWithBankNums(bankNums, [5], valueAtPositions([0, 2, 4], 7))
+ */
+declare const valueAtPositions: (allowedPositions: number[], value: number) => ArrayRule;
+
+/**
+ * Y-ary package entry point
+ * Export your public API here
+ */
+declare function hello(name: string): string;
+
+export { type ArrayRule, alternateEvenOdd, and, arrayWithBankNums, ascending, averageInRange, balanceEvenOdd, byPosition, descending, different, divisibleBy, formulaInterpreter, hello, inRange, maxDifference, maxOccurrences, minDifference, noConsecutiveRepeats, noDuplicates, noRepeatInLast, not, notDivisibleBy, notInRange, onEvenPositions, onOddPositions, onlyEven, onlyOdd, onlyPrimes, onlySquares, or, sumGreaterThan, sumLessThan, valueAtPositions };