@jackens/nnn 2024.2.11 → 2024.2.12

package/pick.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A helper that implements TypeScript’s `Omit` utility type.
+ */
+export const omit: <T extends Partial<Record<PropertyKey, any>>, K extends (keyof T)[]>(obj: T, keys: K) => Omit<T, K[number]>;
+
+/**
+ * A helper that implements TypeScript’s `Pick` utility type.
+ */
+export const pick: <T extends Partial<Record<PropertyKey, any>>, K extends (keyof T)[]>(obj: T, keys: K) => Pick<T, K[number]>;
+
+export namespace tests {
+    function pick(expect: import("bun:test").Expect): void;
+    function omit(expect: import("bun:test").Expect): void;
+}

package/pick.js

@@ -0,0 +1,57 @@
+/**
+ * A helper that implements TypeScript’s `Pick` utility type.
+ *
+ * @type {<T extends Partial<Record<PropertyKey, any>>, K extends (keyof T)[]>(obj: T, keys: K) => Pick<T, K[number]>}
+ * @template {Partial<Record<PropertyKey, any>>} T
+ * @template {keyof T} K
+ */
+export const pick = (/** @type {T} */ obj, /** @type {K[]} */ keys) => {
+  const result = {}
+
+  for (const key in obj) {
+    // @ts-ignore
+    if (keys.includes(key)) {
+      // @ts-ignore
+      result[key] = obj[key]
+    }
+  }
+
+  // @ts-ignore
+  return result
+}
+
+/**
+ * A helper that implements TypeScript’s `Omit` utility type.
+ *
+ * @type {<T extends Partial<Record<PropertyKey, any>>, K extends (keyof T)[]>(obj: T, keys: K) => Omit<T, K[number]>}
+ * @template {Partial<Record<PropertyKey, any>>} T
+ * @template {keyof T} K
+ */
+export const omit = (/** @type {T} */ obj, /** @type {K[]} */ keys) => {
+  const result = {}
+
+  for (const key in obj) {
+    // @ts-ignore
+    if (!keys.includes(key)) {
+      // @ts-ignore
+      result[key] = obj[key]
+    }
+  }
+
+  // @ts-ignore
+  return result
+}
+
+export const tests = {
+  pick: (/** @type {import('bun:test').Expect} */ expect) => {
+    const obj = { a: 42, b: '42', c: 17 }
+
+    expect(pick(obj, ['a', 'b'])).toEqual({ a: 42, b: '42' })
+  },
+
+  omit: (/** @type {import('bun:test').Expect} */ expect) => {
+    const obj = { a: 42, b: '42', c: 17 }
+
+    expect(omit(obj, ['c'])).toEqual({ a: 42, b: '42' })
+  }
+}

package/plUral.d.ts

@@ -4,5 +4,5 @@
 export function plUral(singular: string, plural2: string, plural5: string, value: number): string;
 
 export namespace tests {
-    function plUral(): void;
+    function plUral(expect: import("bun:test").Expect): void;
 }

package/plUral.js

@@ -19,21 +19,21 @@ export const plUral = (
 }
 
 export const tests = {
-  plUral: () => {
+  plUral: (/** @type {import('bun:test').Expect} */ expect) => {
     // @ts-ignore
     const auto = plUral.bind(null, 'auto', 'auta', 'aut')
 
-    console.assert(auto(0) === 'aut')
-    console.assert(auto(1) === 'auto')
-    console.assert(auto(17) === 'aut')
-    console.assert(auto(42) === 'auta')
+    expect(auto(0)).toEqual('aut')
+    expect(auto(1)).toEqual('auto')
+    expect(auto(17)).toEqual('aut')
+    expect(auto(42)).toEqual('auta')
 
     // @ts-ignore
     const car = plUral.bind(null, 'car', 'cars', 'cars')
 
-    console.assert(car(0) === 'cars')
-    console.assert(car(1) === 'car')
-    console.assert(car(17) === 'cars')
-    console.assert(car(42) === 'cars')
+    expect(car(0)).toEqual('cars')
+    expect(car(1)).toEqual('car')
+    expect(car(17)).toEqual('cars')
+    expect(car(42)).toEqual('cars')
   }
 }

package/pro.d.ts

@@ -4,5 +4,5 @@
 export function pro(ref: any): any;
 
 export namespace tests {
-    function pro(): void;
+    function pro(expect: import("bun:test").Expect): void;
 }

package/pro.js

@@ -1,5 +1,3 @@
-import { eq } from './eq.js'
-
 /**
  * A helper that protects calls to nested properties by a `Proxy` that initializes non-existent values with an empty object.
  */
@@ -11,31 +9,31 @@ export const pro = (/** @type {any} */ ref) => new Proxy(ref, {
 })
 
 export const tests = {
-  pro: () => {
+  pro: (/** @type {import('bun:test').Expect} */ expect) => {
     const ref = {}
 
     pro(ref).one.two[3][4] = 1234
 
-    console.assert(eq(ref, { one: { two: { 3: { 4: 1234 } } } }))
+    expect(ref).toEqual({ one: { two: { 3: { 4: 1234 } } } })
 
     pro(ref).one.two.tree = 123
 
-    console.assert(eq(ref, { one: { two: { 3: { 4: 1234 }, tree: 123 } } }))
+    expect(ref).toEqual({ one: { two: { 3: { 4: 1234 }, tree: 123 } } })
 
     pro(ref).one.two = undefined
 
-    console.assert(eq(ref, { one: { two: undefined } }))
+    expect(ref).toEqual({ one: { two: undefined } })
 
     delete pro(ref).one.two
 
-    console.assert(eq(ref, { one: {} }))
+    expect(ref).toEqual({ one: {} })
 
     pro(ref).one.two.three.four
 
-    console.assert(eq(ref, { one: { two: { three: { four: {} } } } }))
+    expect(ref).toEqual({ one: { two: { three: { four: {} } } } })
 
     pro(ref).one.two.three.four = 1234
 
-    console.assert(eq(ref, { one: { two: { three: { four: 1234 } } } }))
+    expect(ref).toEqual({ one: { two: { three: { four: 1234 } } } })
   }
 }