@thi.ng/compare 2.1.37 → 2.2.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-08-22T14:39:27Z
+- **Last updated**: 2023-09-15T12:33:37Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,12 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [2.2.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/compare@2.2.0) (2023-09-15)
+
+#### 🚀 Features
+
+- add comparison operators/predicates ([5a627b1](https://github.com/thi-ng/umbrella/commit/5a627b1))
+
 ## [2.1.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/compare@2.1.0) (2021-11-17)
 
 #### 🚀 Features

package/README.md

@@ -58,7 +58,7 @@ For Node.js REPL:
 const compare = await import("@thi.ng/compare");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 393 bytes
+Package sizes (brotli'd, pre-treeshake): ESM: 598 bytes
 
 ## Dependencies
 

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./compare.js";
 export * from "./keys.js";
 export * from "./numeric.js";
+export * from "./ops.js";
 export * from "./reverse.js";
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,4 +1,5 @@
 export * from "./compare.js";
 export * from "./keys.js";
 export * from "./numeric.js";
+export * from "./ops.js";
 export * from "./reverse.js";

package/ops.d.ts

@@ -0,0 +1,74 @@
+import type { Predicate2 } from "@thi.ng/api";
+export type Operator = "=" | "!=" | "<" | "<=" | ">=" | ">";
+export declare const OPERATORS: Record<Operator, Predicate2<string> | Predicate2<number>>;
+/**
+ * Takes a comparison operator (either as string alias or function) and the RHS arg
+ * for it, returns a new function for given operator which only takes a single
+ * arg (i.e. the LHS of the operator) and always coerces it to a string before
+ * applying the operator.
+ *
+ * @remarks
+ * See {@link numericOp} for related functionality.
+ *
+ * @example
+ * ```ts
+ * const equalsABC = stringOp("=", "abc");
+ *
+ * ["xyz", "abc", "def"].map(equalsABC)
+ * // [ false, true, false ]
+ *
+ * class X {
+ *   constructor(public body: string) {}
+ *
+ *   toString() {
+ *     return this.body;
+ *   }
+ * }
+ *
+ * equalsABC(new X("abc"))
+ * // true
+ * ```
+ *
+ * @param op
+ * @param x
+ */
+export declare const stringOp: (op: Operator | Predicate2<string>, x: string) => (y: any) => boolean;
+/**
+ * Similar to {@link stringOp}, but for numeric args. Takes a comparison
+ * operator (either as string alias or function) and the RHS arg for it, returns
+ * a new function for given operator which only takes a single arg (i.e. the LHS
+ * of the operator) and then checks if that arg is a number before applying the
+ * operator. For non-numeric args, the returned function will always return
+ * false.
+ *
+ * @example
+ * ```ts
+ * const lessThan42 = numericOp("<", 42);
+ *
+ * lessThan42(41)
+ * // true
+ *
+ * lessThan42("41")
+ * // false
+ *
+ * lessThan42([41])
+ * // false
+ * ```
+ *
+ * @param op
+ * @param x
+ */
+export declare const numericOp: (op: Operator | Predicate2<number>, x: number) => (y: any) => boolean;
+export declare function eq(a: string, b: string): boolean;
+export declare function eq(a: number, b: number): boolean;
+export declare function neq(a: string, b: string): boolean;
+export declare function neq(a: number, b: number): boolean;
+export declare function lt(a: string, b: string): boolean;
+export declare function lt(a: number, b: number): boolean;
+export declare function lte(a: string, b: string): boolean;
+export declare function lte(a: number, b: number): boolean;
+export declare function gte(a: string, b: string): boolean;
+export declare function gte(a: number, b: number): boolean;
+export declare function gt(a: string, b: string): boolean;
+export declare function gt(a: number, b: number): boolean;
+//# sourceMappingURL=ops.d.ts.map

package/ops.js

@@ -0,0 +1,99 @@
+export const OPERATORS = {
+    "=": eq,
+    "!=": neq,
+    "<": lt,
+    "<=": lte,
+    ">=": gte,
+    ">": gt,
+};
+const __ensure = (op) => {
+    if (typeof op === "string") {
+        if (op in OPERATORS)
+            return OPERATORS[op];
+        else
+            throw new Error(`invalid operator: ${op}`);
+    }
+    return op;
+};
+/**
+ * Takes a comparison operator (either as string alias or function) and the RHS arg
+ * for it, returns a new function for given operator which only takes a single
+ * arg (i.e. the LHS of the operator) and always coerces it to a string before
+ * applying the operator.
+ *
+ * @remarks
+ * See {@link numericOp} for related functionality.
+ *
+ * @example
+ * ```ts
+ * const equalsABC = stringOp("=", "abc");
+ *
+ * ["xyz", "abc", "def"].map(equalsABC)
+ * // [ false, true, false ]
+ *
+ * class X {
+ *   constructor(public body: string) {}
+ *
+ *   toString() {
+ *     return this.body;
+ *   }
+ * }
+ *
+ * equalsABC(new X("abc"))
+ * // true
+ * ```
+ *
+ * @param op
+ * @param x
+ */
+export const stringOp = (op, x) => {
+    const impl = __ensure(op);
+    return (y) => impl(String(y), x);
+};
+/**
+ * Similar to {@link stringOp}, but for numeric args. Takes a comparison
+ * operator (either as string alias or function) and the RHS arg for it, returns
+ * a new function for given operator which only takes a single arg (i.e. the LHS
+ * of the operator) and then checks if that arg is a number before applying the
+ * operator. For non-numeric args, the returned function will always return
+ * false.
+ *
+ * @example
+ * ```ts
+ * const lessThan42 = numericOp("<", 42);
+ *
+ * lessThan42(41)
+ * // true
+ *
+ * lessThan42("41")
+ * // false
+ *
+ * lessThan42([41])
+ * // false
+ * ```
+ *
+ * @param op
+ * @param x
+ */
+export const numericOp = (op, x) => {
+    const impl = __ensure(op);
+    return (y) => typeof y === "number" && impl(y, x);
+};
+export function eq(a, b) {
+    return a === b;
+}
+export function neq(a, b) {
+    return a !== b;
+}
+export function lt(a, b) {
+    return a < b;
+}
+export function lte(a, b) {
+    return a <= b;
+}
+export function gte(a, b) {
+    return a >= b;
+}
+export function gt(a, b) {
+    return a > b;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/compare",
-  "version": "2.1.37",
+  "version": "2.2.0",
   "description": "Comparators with support for types implementing the @thi.ng/api/ICompare interface",
   "type": "module",
   "module": "./index.js",
@@ -34,15 +34,15 @@
     "test": "testament test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.4"
+    "@thi.ng/api": "^8.9.5"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.36.4",
-    "@thi.ng/testament": "^0.3.22",
+    "@thi.ng/testament": "^0.3.23",
     "rimraf": "^5.0.1",
     "tools": "^0.0.1",
-    "typedoc": "^0.24.8",
-    "typescript": "^5.1.6"
+    "typedoc": "^0.25.0",
+    "typescript": "^5.2.2"
   },
   "keywords": [
     "comparator",
@@ -72,9 +72,12 @@
     "./numeric": {
       "default": "./numeric.js"
     },
+    "./ops": {
+      "default": "./ops.js"
+    },
     "./reverse": {
       "default": "./reverse.js"
     }
   },
-  "gitHead": "74cfe3fb8de5bfcbfc1109e67604541cbd7b77aa\n"
+  "gitHead": "b2ef5a1b8932d067af4ec2fc7da03d59d6868dc7\n"
 }