@jackens/nnn 2024.2.10 → 2024.2.12

package/locale.js

@@ -4,7 +4,7 @@ import { is } from './is.js'
  * Language translations helper.
  */
 export const locale = (
-  /** @type {Partial<Record<string, Partial<Record<string, string>>>>} */ map,
+  /** @type {Partial<Record<PropertyKey, Partial<Record<PropertyKey, string>>>>} */ map,
   /** @type {string} */ defaultVersion
 ) => (
   /** @type {string} */ text,
@@ -17,23 +17,23 @@ export const locale = (
 }
 
 export const tests = {
-  locale: () => {
+  locale: (/** @type {import('bun:test').Expect} */ expect) => {
     const _ = locale({
       default: { Password: 'Hasło' },
       button: { Login: 'Zaloguj' }
     }, 'default')
 
-    console.assert(_('Login') === 'Login')
-    console.assert(_('Password') === 'Hasło')
+    expect(_('Login')).toEqual('Login')
+    expect(_('Password')).toEqual('Hasło')
 
-    console.assert(_('Undefined text') === 'Undefined text')
+    expect(_('Undefined text')).toEqual('Undefined text')
 
-    console.assert(_('Login', 'button') === 'Zaloguj')
+    expect(_('Login', 'button')).toEqual('Zaloguj')
 
-    console.assert(_('Password', 'undefined_version') === 'Hasło')
-    console.assert(_('Undefined text', 'undefined_version') === 'Undefined text')
+    expect(_('Password', 'undefined_version')).toEqual('Hasło')
+    expect(_('Undefined text', 'undefined_version')).toEqual('Undefined text')
 
-    console.assert(_('toString') === 'toString')
-    console.assert(_('toString', 'undefined_version') === 'toString')
+    expect(_('toString')).toEqual('toString')
+    expect(_('toString', 'undefined_version')).toEqual('toString')
   }
 }

package/nanolightJs.d.ts

@@ -4,5 +4,5 @@
 export const nanolightJs: (code?: string | undefined) => import("./h.js").HArgs1[];
 
 export namespace tests {
-    function nanolightJs(): void;
+    function nanolightJs(expect: import("bun:test").Expect): void;
 }

package/nanolightJs.js

@@ -20,10 +20,10 @@ export const nanolightJs = nanolight.bind(0,
 )
 
 export const tests = {
-  nanolightJs: () => {
+  nanolightJs: (/** @type {import('bun:test').Expect} */ expect) => {
     const codeJs = 'const answerToLifeTheUniverseAndEverything = 42'
 
-    console.assert(h('pre', ['code', ...nanolightJs(codeJs)]).outerHTML ===
+    expect(h('pre', ['code', ...nanolightJs(codeJs)]).outerHTML).toEqual(
       '<pre><code><span class="keyword">const</span> <span class="literal">answerToLifeTheUniverseAndEverything</span> <span class="operator">=</span> <span class="number">42</span></code></pre>')
   }
 }

package/nnn.d.ts

@@ -11,9 +11,11 @@ import { jsOnParse } from './jsOnParse.js';
 import { locale } from './locale.js';
 import { nanolight } from './nanolight.js';
 import { nanolightJs } from './nanolightJs.js';
+import { omit } from './pick.js';
+import { pick } from './pick.js';
 import { plUral } from './plUral.js';
 import { pro } from './pro.js';
 import { refsInfo } from './refsInfo.js';
 import { s } from './h.js';
 import { uuid1 } from './uuid1.js';
-export { chartable, eq, escape, escapeValues, fixTypography, h, has, is, jcss, jsOnParse, locale, nanolight, nanolightJs, plUral, pro, refsInfo, s, uuid1 };
+export { chartable, eq, escape, escapeValues, fixTypography, h, has, is, jcss, jsOnParse, locale, nanolight, nanolightJs, omit, pick, plUral, pro, refsInfo, s, uuid1 };

package/nnn.js

@@ -10,6 +10,7 @@ import { jsOnParse } from './jsOnParse.js'
 import { locale } from './locale.js'
 import { nanolight } from './nanolight.js'
 import { nanolightJs } from './nanolightJs.js'
+import { omit, pick } from './pick.js'
 import { plUral } from './plUral.js'
 import { pro } from './pro.js'
 import { refsInfo } from './refsInfo.js'
@@ -18,7 +19,8 @@ import { uuid1 } from './uuid1.js'
 export {
   chartable,
   eq,
-  escape, escapeValues,
+  escape,
+  escapeValues,
   fixTypography,
   h,
   has,
@@ -28,6 +30,8 @@ export {
   locale,
   nanolight,
   nanolightJs,
+  omit,
+  pick,
   plUral,
   pro,
   refsInfo,

package/package.json

@@ -40,5 +40,5 @@
   "types": "nnn.d.ts",
   "name": "@jackens/nnn",
   "type": "module",
-  "version": "2024.2.10"
+  "version": "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 } } } })
   }
 }