ctx-core 5.18.4 → 5.18.7

package/all/eq/index.d.ts

@@ -2,14 +2,14 @@ import type { a_nowrap_T } from '../a_nowrap/index.js'
 /**
  * Returns `==` operator to all values in `a_nowrap`.
  */
-export declare function eq<In>(a_nowrap:a_nowrap_T<In>):boolean
+export declare function eq<I>(a_nowrap:a_nowrap_T<I>):boolean
 export declare type eq_T<I> = (a_nowrap:I)=>boolean
 /**
  * Returns function that returns `==` operator to all values in `in_value_aS`.
  */
-export declare function eq_<In>(a_nowrap:a_nowrap_T<In>):eq_fn_T<In>
+export declare function eq_<I>(a_nowrap:a_nowrap_T<unknown>):eq_fn_T<I>
 export {
 	eq_ as _eq,
 	eq_ as _fn__eq,
 }
-export declare type eq_fn_T<In> = (value:In)=>boolean
+export declare type eq_fn_T<I> = (value:I)=>boolean

package/all/eq/index.js

@@ -22,7 +22,7 @@ export function eq(a_nowrap) {
  * @returns {eq_fn_T}
  */
 export function eq_(a_nowrap) {
-	return (value)=>eq(wrap_concat(a_nowrap, value))
+	return value=>eq(wrap_concat(a_nowrap, value))
 }
 export {
 	eq_ as _eq,

package/all/eq/index.test.ts

@@ -0,0 +1,20 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { eq, eq_ } from './index.js'
+test('eq', ()=>{
+	equal(eq([0, 0]), true)
+	equal(eq([0, 1]), false)
+	equal(eq([{}, {}]), false)
+	equal(eq([undefined, {}]), false)
+	equal(eq([undefined, null]), true)
+	equal(eq([undefined, undefined]), true)
+})
+test('eq_', ()=>{
+	equal(eq_(0)(0), true)
+	equal(eq_(0)(1), false)
+	equal(eq_({})({}), false)
+	equal(eq_(undefined)({}), false)
+	equal(eq_(undefined)(null), true)
+	equal(eq_(undefined)(undefined), true)
+})
+test.run()

package/all/eql/index.d.ts

@@ -1,3 +1,4 @@
+import type { a_nowrap_T } from '../a_nowrap/index.js'
 /**
  * Returns `===` operator to all values in `a_unwrap`.
  */
@@ -5,12 +6,12 @@ export declare function eql<I>(a_unwrap:I):boolean
 /**
  * Returns function that returns `===` operator to all values in `in_value_a`.
  */
-export declare function eql_<Val>(in_value_a:Val[]):(val:Val)=>boolean
+export declare function eql_<I>(in_value_a:a_nowrap_T<unknown>):(val:I)=>boolean
 export { eql_ as _eql, }
 /**
  * Returns function that applies `===` operator to `compare` & `value`.
  */
-export declare function eql_2<Val>(compare:Val):(val:Val)=>boolean
+export declare function eql_2<I>(compare:I):(val:I)=>boolean
 export {
 	eql_2 as _eql_fn,
 	eql_2 as _fn__eql,

package/all/eql/index.js

@@ -6,11 +6,9 @@ import { wrap_concat } from '../wrap_concat/index.js'
  * @returns {boolean}
  */
 export function eql(a_unwrap) {
-	const value_a = wrap_a_(a_unwrap)
-	let current_value = value_a[0]
-	for (let i = 1; i < value_a.length; i++) {
-		const value = value_a[i]
-		if (current_value !== value) return false
+	let [cmp_val, ...rest] = wrap_a_(a_unwrap)
+	for (let val of rest) {
+		if (cmp_val !== val) return false
 	}
 	return true
 }

package/all/eql/index.test.ts

@@ -0,0 +1,20 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { eql, eql_ } from './index.js'
+test('eql', ()=>{
+	equal(eql([0, 0]), true)
+	equal(eql([0, 1]), false)
+	equal(eql([{}, {}]), false)
+	equal(eql([undefined, {}]), false)
+	equal(eql([undefined, null]), false)
+	equal(eql([undefined, undefined]), true)
+})
+test('eql_', ()=>{
+	equal(eql_(0)(0), true)
+	equal(eql_(0)(1), false)
+	equal(eql_({})({}), false)
+	equal(eql_(undefined)({}), false)
+	equal(eql_(undefined)(null), false)
+	equal(eql_(undefined)(undefined), true)
+})
+test.run()

package/all/neq/index.d.ts

@@ -1,10 +1,10 @@
-import type { wrap_a_T } from '../wrap_a/index.js'
+import type { a_nowrap_T } from '../a_nowrap/index.js'
 /**
  * Returns `!=` operator to all values in `in_value_a`.
  */
-export declare function neq<I>(in_value_a:wrap_a_T<I>):boolean
+export declare function neq<I>(a_unwrap:I):boolean
 /**
  * Return function that Returns `!=` operator to all values in `in_value_a`.
  */
-export declare function neq_<I>(in_value_a:I|I[]):(val:I)=>boolean
+export declare function neq_<I>(in_value_a:a_nowrap_T<unknown>):(val:I)=>boolean
 export { neq_ as _neq, }

package/all/neq/index.js

@@ -7,11 +7,9 @@ import { wrap_concat } from '../wrap_concat/index.js'
  * @returns {boolean}
  */
 export function neq(in_value_a) {
-	const value_a = wrap_a_(in_value_a)
-	let current_value = value_a[0]
-	for (let i = 1; i < value_a.length; i++) {
-		const value = value_a[i]
-		if (current_value == value) return false
+	let [cmp_val, ...rest] = wrap_a_(in_value_a)
+	for (let val of rest) {
+		if (cmp_val == val) return false
 	}
 	return true
 }

package/all/neq/index.test.ts

@@ -0,0 +1,20 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { neq, neq_ } from './index.js'
+test('neq', ()=>{
+	equal(neq([0, 0]), false)
+	equal(neq([0, 1]), true)
+	equal(neq([{}, {}]), true)
+	equal(neq([undefined, {}]), true)
+	equal(neq([undefined, null]), false)
+	equal(neq([undefined, undefined]), false)
+})
+test('neq_', ()=>{
+	equal(neq_(0)(0), false)
+	equal(neq_(0)(1), true)
+	equal(neq_({})({}), true)
+	equal(neq_(undefined)({}), true)
+	equal(neq_(undefined)(null), false)
+	equal(neq_(undefined)(undefined), false)
+})
+test.run()

package/all/neql/index.d.ts

@@ -1,3 +1,4 @@
+import type { a_nowrap_T } from '../a_nowrap/index.js'
 /**
  * Returns `!==` operator to all values in `a_unwrap`.
  */
@@ -7,5 +8,7 @@ export declare function neql<I>(a_unwrap:I):boolean
  * @param in_value_a
  * @returns {function(*=): boolean}
  */
-export declare function neql_<Arg>(in_value_a:Arg[]):(value:Arg)=>boolean
+export declare function neql_<I>(
+	in_value_a:a_nowrap_T<unknown>
+):(value:I)=>boolean
 export { neql_ as _neql, }

package/all/neql/index.js

@@ -1,15 +1,14 @@
 import { wrap_a_ } from '../wrap_a/index.js'
+import { wrap_concat } from '../wrap_concat/index.js'
 /**
  * Returns `!==` operator to all values in `a_unwrap`.
  * @param {unknown}a_unwrap
  * @returns {boolean}
  */
 export function neql(a_unwrap) {
-	const value_a = wrap_a_(a_unwrap)
-	let current_value = value_a[0]
-	for (let i = 1; i < value_a.length; i++) {
-		const value = value_a[i]
-		if (current_value === value) return false
+	let [cmp_val, ...rest] = wrap_a_(a_unwrap)
+	for (let val of rest) {
+		if (cmp_val === val) return false
 	}
 	return true
 }
@@ -19,6 +18,6 @@ export function neql(a_unwrap) {
  * @returns {(value:unknown)=>boolean}
  */
 export function neql_(in_value_a) {
-	return (value)=>neql(wrap_concat(in_value_a, value))
+	return value=>neql(wrap_concat(in_value_a, value))
 }
 export { neql_ as _neql, }

package/all/neql/index.test.ts

@@ -0,0 +1,20 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { neql, neql_ } from './index.js'
+test('neql', ()=>{
+	equal(neql([0, 0]), false)
+	equal(neql([0, 1]), true)
+	equal(neql([{}, {}]), true)
+	equal(neql([undefined, {}]), true)
+	equal(neql([undefined, null]), true)
+	equal(neql([undefined, undefined]), false)
+})
+test('neql_', ()=>{
+	equal(neql_(0)(0), false)
+	equal(neql_(0)(1), true)
+	equal(neql_({})({}), true)
+	equal(neql_(undefined)({}), true)
+	equal(neql_(undefined)(null), true)
+	equal(neql_(undefined)(undefined), false)
+})
+test.run()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "5.18.4",
+  "version": "5.18.7",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -134,7 +134,7 @@
     "@arethetypeswrong/cli": "^0.13.5",
     "@ctx-core/preprocess": "^0.1.0",
     "@size-limit/preset-small-lib": "^11.0.1",
-    "@types/node": "^20.11.1",
+    "@types/node": "^20.11.2",
     "@types/sinon": "^17.0.3",
     "c8": "^9.1.0",
     "check-dts": "^0.7.2",