@higher.archi/boe 1.0.0

package/src/core/operators/arithmetic/multiply.ts

@@ -0,0 +1,40 @@
+/**
+ * Multiply Operator
+ *
+ * Multiplication operations for numbers.
+ */
+
+import { binaryOp, variadicOp } from '../operator';
+import { Operator } from '../types';
+
+/**
+ * Multiply operator (binary) - multiplies two numbers
+ */
+export const multiply: Operator = binaryOp<number>(
+  'multiply',
+  (a, b) => a * b,
+  {
+    leftType: 'number',
+    rightType: 'number',
+    returns: 'number',
+    category: 'arithmetic',
+    description: 'Multiplies two numbers',
+    aliases: ['times', '*'],
+  }
+);
+
+/**
+ * Product operator (variadic) - multiplies all numbers
+ */
+export const product: Operator = variadicOp<number>(
+  'product',
+  (...args) => args.reduce((acc, val) => acc * val, 1),
+  {
+    paramType: 'number',
+    returns: 'number',
+    category: 'arithmetic',
+    description: 'Multiplies all numbers together',
+  }
+);
+
+export default [multiply, product];

package/src/core/operators/arithmetic/number-checks.ts

@@ -0,0 +1,123 @@
+/**
+ * Number Check Operators
+ *
+ * Operators for checking number properties.
+ */
+
+import { unaryOp } from '../operator';
+import { Operator } from '../types';
+
+/**
+ * Is NaN operator
+ */
+export const isNaN: Operator = unaryOp<number>(
+  'isNaN',
+  (a) => Number.isNaN(a),
+  {
+    paramType: 'number',
+    returns: 'boolean',
+    category: 'arithmetic',
+    description: 'Checks if a value is NaN (Not a Number)',
+  }
+);
+
+/**
+ * Is finite operator
+ */
+export const isFinite: Operator = unaryOp<number>(
+  'isFinite',
+  (a) => Number.isFinite(a),
+  {
+    paramType: 'number',
+    returns: 'boolean',
+    category: 'arithmetic',
+    description: 'Checks if a value is a finite number',
+  }
+);
+
+/**
+ * Is integer operator
+ */
+export const isInteger: Operator = unaryOp<number>(
+  'isInteger',
+  (a) => Number.isInteger(a),
+  {
+    paramType: 'number',
+    returns: 'boolean',
+    category: 'arithmetic',
+    description: 'Checks if a value is an integer',
+    aliases: ['isInt'],
+  }
+);
+
+/**
+ * Is odd operator
+ */
+export const isOdd: Operator = unaryOp<number>(
+  'isOdd',
+  (a) => a % 2 !== 0,
+  {
+    paramType: 'number',
+    returns: 'boolean',
+    category: 'arithmetic',
+    description: 'Checks if a number is odd',
+  }
+);
+
+/**
+ * Is even operator
+ */
+export const isEven: Operator = unaryOp<number>(
+  'isEven',
+  (a) => a % 2 === 0,
+  {
+    paramType: 'number',
+    returns: 'boolean',
+    category: 'arithmetic',
+    description: 'Checks if a number is even',
+  }
+);
+
+/**
+ * Is positive operator
+ */
+export const isPositive: Operator = unaryOp<number>(
+  'isPositive',
+  (a) => a > 0,
+  {
+    paramType: 'number',
+    returns: 'boolean',
+    category: 'arithmetic',
+    description: 'Checks if a number is positive',
+  }
+);
+
+/**
+ * Is negative operator
+ */
+export const isNegative: Operator = unaryOp<number>(
+  'isNegative',
+  (a) => a < 0,
+  {
+    paramType: 'number',
+    returns: 'boolean',
+    category: 'arithmetic',
+    description: 'Checks if a number is negative',
+  }
+);
+
+/**
+ * Is zero operator
+ */
+export const isZero: Operator = unaryOp<number>(
+  'isZero',
+  (a) => a === 0,
+  {
+    paramType: 'number',
+    returns: 'boolean',
+    category: 'arithmetic',
+    description: 'Checks if a number is zero',
+  }
+);
+
+export default [isNaN, isFinite, isInteger, isOdd, isEven, isPositive, isNegative, isZero];

package/src/core/operators/arithmetic/power.ts

@@ -0,0 +1,40 @@
+/**
+ * Power Operator
+ *
+ * Exponentiation and root operations.
+ */
+
+import { binaryOp, unaryOp } from '../operator';
+import { Operator } from '../types';
+
+/**
+ * Power operator - raises first number to the power of second
+ */
+export const power: Operator = binaryOp<number>(
+  'power',
+  (a, b) => Math.pow(a, b),
+  {
+    leftType: 'number',
+    rightType: 'number',
+    returns: 'number',
+    category: 'arithmetic',
+    description: 'Raises the first number to the power of the second',
+    aliases: ['pow', '**', '^'],
+  }
+);
+
+/**
+ * Square root operator
+ */
+export const sqrt: Operator = unaryOp<number>(
+  'sqrt',
+  (a) => Math.sqrt(a),
+  {
+    paramType: 'number',
+    returns: 'number',
+    category: 'arithmetic',
+    description: 'Returns the square root of a number',
+  }
+);
+
+export default [power, sqrt];

package/src/core/operators/arithmetic/rounding.ts

@@ -0,0 +1,83 @@
+/**
+ * Rounding Operators
+ *
+ * Operations to round numbers.
+ */
+
+import { unaryOp } from '../operator';
+import { Operator } from '../types';
+
+/**
+ * Round operator - rounds to nearest integer
+ */
+export const round: Operator = unaryOp<number>(
+  'round',
+  (a) => Math.round(a),
+  {
+    paramType: 'number',
+    returns: 'number',
+    category: 'arithmetic',
+    description: 'Rounds a number to the nearest integer',
+  }
+);
+
+/**
+ * Floor operator - rounds down to integer
+ */
+export const floor: Operator = unaryOp<number>(
+  'floor',
+  (a) => Math.floor(a),
+  {
+    paramType: 'number',
+    returns: 'number',
+    category: 'arithmetic',
+    description: 'Rounds a number down to the nearest integer',
+  }
+);
+
+/**
+ * Ceil operator - rounds up to integer
+ */
+export const ceil: Operator = unaryOp<number>(
+  'ceil',
+  (a) => Math.ceil(a),
+  {
+    paramType: 'number',
+    returns: 'number',
+    category: 'arithmetic',
+    description: 'Rounds a number up to the nearest integer',
+    aliases: ['ceiling'],
+  }
+);
+
+/**
+ * Truncate operator - removes decimal portion
+ */
+export const trunc: Operator = unaryOp<number>(
+  'trunc',
+  (a) => Math.trunc(a),
+  {
+    paramType: 'number',
+    returns: 'number',
+    category: 'arithmetic',
+    description: 'Removes the decimal portion of a number',
+    aliases: ['truncate'],
+  }
+);
+
+/**
+ * Absolute value operator
+ */
+export const abs: Operator = unaryOp<number>(
+  'abs',
+  (a) => Math.abs(a),
+  {
+    paramType: 'number',
+    returns: 'number',
+    category: 'arithmetic',
+    description: 'Returns the absolute value of a number',
+    aliases: ['absolute'],
+  }
+);
+
+export default [round, floor, ceil, trunc, abs];

package/src/core/operators/arithmetic/subtract.ts

@@ -0,0 +1,41 @@
+/**
+ * Subtract Operator
+ *
+ * Subtraction operations for numbers.
+ */
+
+import { binaryOp, unaryOp } from '../operator';
+import { Operator } from '../types';
+
+/**
+ * Subtract operator - subtracts second number from first
+ */
+export const subtract: Operator = binaryOp<number>(
+  'subtract',
+  (a, b) => a - b,
+  {
+    leftType: 'number',
+    rightType: 'number',
+    returns: 'number',
+    category: 'arithmetic',
+    description: 'Subtracts the second number from the first',
+    aliases: ['minus', '-'],
+  }
+);
+
+/**
+ * Negate operator - negates a number
+ */
+export const negate: Operator = unaryOp<number>(
+  'negate',
+  (a) => -a,
+  {
+    paramType: 'number',
+    returns: 'number',
+    category: 'arithmetic',
+    description: 'Negates a number (multiplies by -1)',
+    aliases: ['neg'],
+  }
+);
+
+export default [subtract, negate];

package/src/core/operators/array/contains.ts

@@ -0,0 +1,85 @@
+/**
+ * Array Contains Operators
+ *
+ * Checks if arrays contain elements.
+ */
+
+import { binaryOp, unaryOp } from '../operator';
+import { Operator } from '../types';
+
+/**
+ * Array contains - checks if array contains an element
+ */
+export const arrayContains: Operator = binaryOp<unknown[], unknown>(
+  'arrayContains',
+  (arr, element) => arr.includes(element),
+  {
+    leftType: 'array',
+    rightType: 'any',
+    returns: 'boolean',
+    category: 'array',
+    description: 'Checks if an array contains a specific element',
+    aliases: ['includes', 'has'],
+  }
+);
+
+/**
+ * In - checks if element is in array (reversed args)
+ */
+export const inArray: Operator = binaryOp<unknown, unknown[]>(
+  'in',
+  (element, arr) => arr.includes(element),
+  {
+    leftType: 'any',
+    rightType: 'array',
+    returns: 'boolean',
+    category: 'array',
+    description: 'Checks if an element is in an array',
+    aliases: ['memberOf'],
+  }
+);
+
+/**
+ * Array is empty
+ */
+export const arrayIsEmpty: Operator = unaryOp<unknown[]>(
+  'arrayIsEmpty',
+  (arr) => arr.length === 0,
+  {
+    paramType: 'array',
+    returns: 'boolean',
+    category: 'array',
+    description: 'Checks if an array is empty',
+  }
+);
+
+/**
+ * Array is not empty
+ */
+export const arrayIsNotEmpty: Operator = unaryOp<unknown[]>(
+  'arrayIsNotEmpty',
+  (arr) => arr.length > 0,
+  {
+    paramType: 'array',
+    returns: 'boolean',
+    category: 'array',
+    description: 'Checks if an array is not empty',
+  }
+);
+
+/**
+ * Array length
+ */
+export const arrayLength: Operator = unaryOp<unknown[]>(
+  'arrayLength',
+  (arr) => arr.length,
+  {
+    paramType: 'array',
+    returns: 'number',
+    category: 'array',
+    description: 'Returns the length of an array',
+    aliases: ['length', 'count', 'size'],
+  }
+);
+
+export default [arrayContains, inArray, arrayIsEmpty, arrayIsNotEmpty, arrayLength];

package/src/core/operators/array/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Array Operators
+ *
+ * Exports all array operators for registry registration.
+ */
+
+import containsOps from './contains';
+
+export * from './contains';
+
+/**
+ * All array operators as an array for bulk registration
+ */
+export const arrayOperators = [
+  ...containsOps,
+];
+
+export default arrayOperators;

package/src/core/operators/comparison/approximately-equals.ts

@@ -0,0 +1,45 @@
+/**
+ * Approximately Equals Operator
+ *
+ * Checks if two numbers are approximately equal within a tolerance.
+ */
+
+import { ternaryOp, binaryOp } from '../operator';
+import { Operator } from '../types';
+
+/**
+ * Default tolerance for approximate equality
+ */
+const DEFAULT_TOLERANCE = 0.0001;
+
+/**
+ * Approximately equals with explicit tolerance (ternary)
+ */
+export const approximatelyEqualsWithTolerance: Operator = ternaryOp<number>(
+  'approximatelyEqualsWithTolerance',
+  (a: number, b: number, tolerance: number) => Math.abs(a - b) <= tolerance,
+  {
+    params: ['number', 'number', 'number'],
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if two numbers are approximately equal within a specified tolerance',
+  }
+);
+
+/**
+ * Approximately equals with default tolerance (binary)
+ */
+export const approximatelyEquals: Operator = binaryOp<number>(
+  'approximatelyEquals',
+  (a: number, b: number) => Math.abs(a - b) <= DEFAULT_TOLERANCE,
+  {
+    leftType: 'number',
+    rightType: 'number',
+    returns: 'boolean',
+    category: 'comparison',
+    description: `Checks if two numbers are approximately equal (tolerance: ${DEFAULT_TOLERANCE})`,
+    aliases: ['approxEq', '~='],
+  }
+);
+
+export default [approximatelyEquals, approximatelyEqualsWithTolerance];

package/src/core/operators/comparison/equals.ts

@@ -0,0 +1,49 @@
+/**
+ * Equals Operator
+ *
+ * Checks strict equality between two values.
+ * Supports multiple types with type-specific implementations.
+ */
+
+import { polymorphicOp } from '../operator';
+import { PolymorphicOperator } from '../types';
+
+/**
+ * Equals operator - checks if two values are strictly equal
+ */
+export const equals: PolymorphicOperator = polymorphicOp(
+  'equals',
+  {
+    string: (a: string, b: string) => a === b,
+    number: (a: number, b: number) => a === b,
+    boolean: (a: boolean, b: boolean) => a === b,
+    date: (a: Date, b: Date) => a.getTime() === b.getTime(),
+    any: (a: any, b: any) => a === b,
+  },
+  {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if two values are strictly equal',
+    aliases: ['eq', '===', '=='],
+  }
+);
+
+/**
+ * Equals ignore case - string-specific case-insensitive comparison
+ */
+export const equalsIgnoreCase: PolymorphicOperator = polymorphicOp(
+  'equalsIgnoreCase',
+  {
+    string: (a: string, b: string) => a.toLowerCase() === b.toLowerCase(),
+  },
+  {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if two strings are equal, ignoring case',
+    aliases: ['eqIgnoreCase'],
+  }
+);
+
+export default [equals, equalsIgnoreCase];

package/src/core/operators/comparison/greater-than.ts

@@ -0,0 +1,53 @@
+/**
+ * Greater Than Operators
+ *
+ * Checks if the first value is greater than the second.
+ * Supports multiple types with type-specific implementations.
+ */
+
+import { polymorphicOp } from '../operator';
+import { PolymorphicOperator } from '../types';
+
+/**
+ * Greater than operator
+ */
+export const greaterThan: PolymorphicOperator = polymorphicOp(
+  'greaterThan',
+  {
+    number: (a: number, b: number) => a > b,
+    string: (a: string, b: string) =>
+      a.localeCompare(b, undefined, { numeric: true }) > 0,
+    date: (a: Date, b: Date) => a.getTime() > b.getTime(),
+    any: (a: any, b: any) => a != null && b != null && a > b,
+  },
+  {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if the first value is greater than the second',
+    aliases: ['gt', '>'],
+  }
+);
+
+/**
+ * Greater than or equals operator
+ */
+export const greaterThanOrEquals: PolymorphicOperator = polymorphicOp(
+  'greaterThanOrEquals',
+  {
+    number: (a: number, b: number) => a >= b,
+    string: (a: string, b: string) =>
+      a.localeCompare(b, undefined, { numeric: true }) >= 0,
+    date: (a: Date, b: Date) => a.getTime() >= b.getTime(),
+    any: (a: any, b: any) => a != null && b != null && a >= b,
+  },
+  {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if the first value is greater than or equal to the second',
+    aliases: ['gte', '>='],
+  }
+);
+
+export default [greaterThan, greaterThanOrEquals];

package/src/core/operators/comparison/index.ts

@@ -0,0 +1,33 @@
+/**
+ * Comparison Operators
+ *
+ * Exports all comparison operators for registry registration.
+ */
+
+import equalsOps from './equals';
+import notEqualsOps from './not-equals';
+import greaterThanOps from './greater-than';
+import lessThanOps from './less-than';
+import nullishOps from './nullish';
+import approximatelyEqualsOps from './approximately-equals';
+
+export * from './equals';
+export * from './not-equals';
+export * from './greater-than';
+export * from './less-than';
+export * from './nullish';
+export * from './approximately-equals';
+
+/**
+ * All comparison operators as an array for bulk registration
+ */
+export const comparisonOperators = [
+  ...equalsOps,
+  ...notEqualsOps,
+  ...greaterThanOps,
+  ...lessThanOps,
+  ...nullishOps,
+  ...approximatelyEqualsOps,
+];
+
+export default comparisonOperators;

package/src/core/operators/comparison/less-than.ts

@@ -0,0 +1,53 @@
+/**
+ * Less Than Operators
+ *
+ * Checks if the first value is less than the second.
+ * Supports multiple types with type-specific implementations.
+ */
+
+import { polymorphicOp } from '../operator';
+import { PolymorphicOperator } from '../types';
+
+/**
+ * Less than operator
+ */
+export const lessThan: PolymorphicOperator = polymorphicOp(
+  'lessThan',
+  {
+    number: (a: number, b: number) => a < b,
+    string: (a: string, b: string) =>
+      a.localeCompare(b, undefined, { numeric: true }) < 0,
+    date: (a: Date, b: Date) => a.getTime() < b.getTime(),
+    any: (a: any, b: any) => a != null && b != null && a < b,
+  },
+  {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if the first value is less than the second',
+    aliases: ['lt', '<'],
+  }
+);
+
+/**
+ * Less than or equals operator
+ */
+export const lessThanOrEquals: PolymorphicOperator = polymorphicOp(
+  'lessThanOrEquals',
+  {
+    number: (a: number, b: number) => a <= b,
+    string: (a: string, b: string) =>
+      a.localeCompare(b, undefined, { numeric: true }) <= 0,
+    date: (a: Date, b: Date) => a.getTime() <= b.getTime(),
+    any: (a: any, b: any) => a != null && b != null && a <= b,
+  },
+  {
+    arity: 'binary',
+    returns: 'boolean',
+    category: 'comparison',
+    description: 'Checks if the first value is less than or equal to the second',
+    aliases: ['lte', '<='],
+  }
+);
+
+export default [lessThan, lessThanOrEquals];