@jackens/nnn 2024.2.17 → 2024.2.20

package/is.js

@@ -18,48 +18,48 @@
 export const is = (/** @type {T} */ type, /** @type {any} */ arg) => arg?.constructor === type
 
 export const tests = {
-  is: (/** @type {import('bun:test').Expect} */ expect) => {
-    expect(is(Number, 42)).toBe(true)
-    expect(is(Number, Number(42))).toBe(true)
+  is: (/** @type {import('chai').expect} */ expect) => {
+    expect(is(Number, 42)).to.be.true
+    expect(is(Number, Number(42))).to.be.true
     // eslint-disable-next-line no-new-wrappers
-    expect(is(Number, new Number(42))).toBe(true)
-    expect(is(Number, NaN)).toBe(true)
-    expect(is(String, '42')).toBe(true)
-    expect(is(String, String('42'))).toBe(true)
+    expect(is(Number, new Number(42))).to.be.true
+    expect(is(Number, NaN)).to.be.true
+    expect(is(String, '42')).to.be.true
+    expect(is(String, String('42'))).to.be.true
     // eslint-disable-next-line no-new-wrappers
-    expect(is(String, new String('42'))).toBe(true)
-    expect(is(Symbol, Symbol('42'))).toBe(true)
-    expect(is(Symbol, Object(Symbol('42')))).toBe(true)
-    expect(is(undefined, undefined)).toBe(true)
-    expect(is(undefined, null)).toBe(true)
-    expect(is(Object, {})).toBe(true)
-    expect(is(Array, [])).toBe(true)
-    expect(is(RegExp, /42/)).toBe(true)
-    expect(is(Date, new Date(42))).toBe(true)
-    expect(is(Set, new Set(['42', 42]))).toBe(true)
-    expect(is(Map, new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]))).toBe(true)
+    expect(is(String, new String('42'))).to.be.true
+    expect(is(Symbol, Symbol('42'))).to.be.true
+    expect(is(Symbol, Object(Symbol('42')))).to.be.true
+    expect(is(undefined, undefined)).to.be.true
+    expect(is(undefined, null)).to.be.true
+    expect(is(Object, {})).to.be.true
+    expect(is(Array, [])).to.be.true
+    expect(is(RegExp, /42/)).to.be.true
+    expect(is(Date, new Date(42))).to.be.true
+    expect(is(Set, new Set(['42', 42]))).to.be.true
+    expect(is(Map, new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]))).to.be.true
   },
 
-  'is: toString.call': (/** @type {import('bun:test').Expect} */ expect) => {
+  'is: toString.call': (/** @type {import('chai').expect} */ expect) => {
     const iz = (/** @type {any} */ type, /** @type {any} */ arg) => ({}).toString.call(arg).slice(8, -1) === type?.name
 
     class FooBar { }
 
-    expect(is(FooBar, new FooBar())).toBe(true)
-    expect(iz(FooBar, new FooBar())).toBe(false)
+    expect(is(FooBar, new FooBar())).to.be.true
+    expect(iz(FooBar, new FooBar())).to.be.false
 
-    expect(is(Object, new FooBar())).toBe(false)
-    expect(iz(Object, new FooBar())).toBe(true)
+    expect(is(Object, new FooBar())).to.be.false
+    expect(iz(Object, new FooBar())).to.be.true
 
     const fakeFooBar = {}
 
     // @ts-expect-error
     fakeFooBar[Symbol.toStringTag] = FooBar.name
 
-    expect(is(FooBar, fakeFooBar)).toBe(false)
-    expect(iz(FooBar, fakeFooBar)).toBe(true)
+    expect(is(FooBar, fakeFooBar)).to.be.false
+    expect(iz(FooBar, fakeFooBar)).to.be.true
 
-    expect(is(Object, fakeFooBar)).toBe(true)
-    expect(iz(Object, fakeFooBar)).toBe(false)
+    expect(is(Object, fakeFooBar)).to.be.true
+    expect(iz(Object, fakeFooBar)).to.be.false
   }
 }

package/jcss.d.ts

@@ -24,10 +24,10 @@ export type JcssRoot = Partial<Record<PropertyKey, JcssNode>>;
 export function jcss(root: JcssRoot, splitter?: string): string;
 
 export const tests: {
-    'jcss: #1': (expect: import('bun:test').Expect) => void;
-    'jcss: #2': (expect: import('bun:test').Expect) => void;
-    'jcss: #3': (expect: import('bun:test').Expect) => void;
-    'jcss: #4': (expect: import('bun:test').Expect) => void;
-    'jcss: #5': (expect: import('bun:test').Expect) => void;
-    'jcss: #6': (expect: import('bun:test').Expect) => void;
+    'jcss: #1': (expect: Chai.ExpectStatic) => void;
+    'jcss: #2': (expect: Chai.ExpectStatic) => void;
+    'jcss: #3': (expect: Chai.ExpectStatic) => void;
+    'jcss: #4': (expect: Chai.ExpectStatic) => void;
+    'jcss: #5': (expect: Chai.ExpectStatic) => void;
+    'jcss: #6': (expect: Chai.ExpectStatic) => void;
 };

package/jcss.js

@@ -97,7 +97,7 @@ export const jcss = (/** @type {JcssRoot} */ root, splitter = '$$') => {
 }
 
 export const tests = {
-  'jcss: #1': (/** @type {import('bun:test').Expect} */ expect) => {
+  'jcss: #1': (/** @type {import('chai').expect} */ expect) => {
     const actual = jcss({
       a: {
         color: 'red',
@@ -120,10 +120,10 @@ export const tests = {
       padding:1
     }`.replace(/\n\s*/g, '')
 
-    expect(actual).toEqual(expected)
+    expect(actual).to.deep.equal(expected)
   },
 
-  'jcss: #2': (/** @type {import('bun:test').Expect} */ expect) => {
+  'jcss: #2': (/** @type {import('chai').expect} */ expect) => {
     const actual = jcss({
       a: {
         '.b': {
@@ -148,10 +148,10 @@ export const tests = {
       padding:1
     }`.replace(/\n\s*/g, '')
 
-    expect(actual).toEqual(expected)
+    expect(actual).to.deep.equal(expected)
   },
 
-  'jcss: #3': (/** @type {import('bun:test').Expect} */ expect) => {
+  'jcss: #3': (/** @type {import('chai').expect} */ expect) => {
     const actual = jcss({
       '@font-face$$1': {
         fontFamily: 'Jackens',
@@ -223,10 +223,10 @@ export const tests = {
       }
     }`.replace(/\n\s*/g, '')
 
-    expect(actual).toEqual(expected)
+    expect(actual).to.deep.equal(expected)
   },
 
-  'jcss: #4': (/** @type {import('bun:test').Expect} */ expect) => {
+  'jcss: #4': (/** @type {import('chai').expect} */ expect) => {
     const actual = jcss({
       a: {
         '.b,.c': {
@@ -246,10 +246,10 @@ export const tests = {
       margin:2
     }`.replace(/\n\s*/g, '')
 
-    expect(actual).toEqual(expected)
+    expect(actual).to.deep.equal(expected)
   },
 
-  'jcss: #5': (/** @type {import('bun:test').Expect} */ expect) => {
+  'jcss: #5': (/** @type {import('chai').expect} */ expect) => {
     const actual = jcss({
       '.b,.c': {
         margin: 1,
@@ -267,10 +267,10 @@ export const tests = {
       margin:2
     }`.replace(/\n\s*/g, '')
 
-    expect(actual).toEqual(expected)
+    expect(actual).to.deep.equal(expected)
   },
 
-  'jcss: #6': (/** @type {import('bun:test').Expect} */ expect) => {
+  'jcss: #6': (/** @type {import('chai').expect} */ expect) => {
     const actual = jcss({
       '.a,.b': {
         margin: 1,
@@ -288,6 +288,6 @@ export const tests = {
       margin:2
     }`.replace(/\n\s*/g, '')
 
-    expect(actual).toEqual(expected)
+    expect(actual).to.deep.equal(expected)
   }
 }

package/jsOnParse.d.ts

@@ -16,5 +16,5 @@
 export function jsOnParse(handlers: Partial<Record<PropertyKey, Function>>, text: string): any;
 
 export namespace tests {
-    function jsOnParse(expect: import("bun:test").Expect): void;
+    function jsOnParse(expect: Chai.ExpectStatic): void;
 }

package/jsOnParse.js

@@ -40,7 +40,7 @@ export const jsOnParse = (
 })
 
 export const tests = {
-  jsOnParse: (/** @type {import('bun:test').Expect} */ expect) => {
+  jsOnParse: (/** @type {import('chai').expect} */ expect) => {
     const handlers = {
       $hello: (/** @type {string} */ name) => `Hello ${name}!`,
       $foo: () => 'bar'
@@ -80,6 +80,6 @@ export const tests = {
       }
     ]
 
-    expect(actual).toEqual(expected)
+    expect(actual).to.deep.equal(expected)
   }
 }

package/locale.d.ts

@@ -4,5 +4,5 @@
 export function locale(map: Partial<Record<PropertyKey, Partial<Record<PropertyKey, string>>>>, defaultVersion: string): (text: string, version?: string) => string;
 
 export namespace tests {
-    function locale(expect: import("bun:test").Expect): void;
+    function locale(expect: Chai.ExpectStatic): void;
 }

package/locale.js

@@ -17,23 +17,23 @@ export const locale = (
 }
 
 export const tests = {
-  locale: (/** @type {import('bun:test').Expect} */ expect) => {
+  locale: (/** @type {import('chai').expect} */ expect) => {
     const _ = locale({
       default: { Password: 'Hasło' },
       button: { Login: 'Zaloguj' }
     }, 'default')
 
-    expect(_('Login')).toEqual('Login')
-    expect(_('Password')).toEqual('Hasło')
+    expect(_('Login')).to.deep.equal('Login')
+    expect(_('Password')).to.deep.equal('Hasło')
 
-    expect(_('Undefined text')).toEqual('Undefined text')
+    expect(_('Undefined text')).to.deep.equal('Undefined text')
 
-    expect(_('Login', 'button')).toEqual('Zaloguj')
+    expect(_('Login', 'button')).to.deep.equal('Zaloguj')
 
-    expect(_('Password', 'undefined_version')).toEqual('Hasło')
-    expect(_('Undefined text', 'undefined_version')).toEqual('Undefined text')
+    expect(_('Password', 'undefined_version')).to.deep.equal('Hasło')
+    expect(_('Undefined text', 'undefined_version')).to.deep.equal('Undefined text')
 
-    expect(_('toString')).toEqual('toString')
-    expect(_('toString', 'undefined_version')).toEqual('toString')
+    expect(_('toString')).to.deep.equal('toString')
+    expect(_('toString', 'undefined_version')).to.deep.equal('toString')
   }
 }

package/nanolightJs.d.ts

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

package/nanolightJs.js

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

package/package.json

@@ -27,6 +27,8 @@
     "localization",
     "nanolight",
     "nnn",
+    "omit",
+    "pick",
     "RWD",
     "SVG",
     "translation",
@@ -40,5 +42,5 @@
   "types": "nnn.d.ts",
   "name": "@jackens/nnn",
   "type": "module",
-  "version": "2024.2.17"
+  "version": "2024.2.20"
 }

package/pick.d.ts

@@ -9,6 +9,6 @@ export const omit: <T extends Partial<Record<PropertyKey, any>>, K extends (keyo
 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;
+    function pick(expect: Chai.ExpectStatic): void;
+    function omit(expect: Chai.ExpectStatic): void;
 }

package/pick.js

@@ -17,15 +17,15 @@ export const omit = (/** @type {Partial<Record<PropertyKey, any>>} */ obj, /** @
   Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)))
 
 export const tests = {
-  pick: (/** @type {import('bun:test').Expect} */ expect) => {
+  pick: (/** @type {import('chai').expect} */ expect) => {
     const obj = { a: 42, b: '42', c: 17 }
 
-    expect(pick(obj, ['a', 'b'])).toEqual({ a: 42, b: '42' })
+    expect(pick(obj, ['a', 'b'])).to.deep.equal({ a: 42, b: '42' })
   },
 
-  omit: (/** @type {import('bun:test').Expect} */ expect) => {
+  omit: (/** @type {import('chai').expect} */ expect) => {
     const obj = { a: 42, b: '42', c: 17 }
 
-    expect(omit(obj, ['c'])).toEqual({ a: 42, b: '42' })
+    expect(omit(obj, ['c'])).to.deep.equal({ 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(expect: import("bun:test").Expect): void;
+    function plUral(expect: Chai.ExpectStatic): void;
 }

package/plUral.js

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

package/pro.d.ts

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

package/pro.js

@@ -9,31 +9,31 @@ export const pro = (/** @type {any} */ ref) => new Proxy(ref, {
 })
 
 export const tests = {
-  pro: (/** @type {import('bun:test').Expect} */ expect) => {
+  pro: (/** @type {import('chai').expect} */ expect) => {
     const ref = {}
 
     pro(ref).one.two[3][4] = 1234
 
-    expect(ref).toEqual({ one: { two: { 3: { 4: 1234 } } } })
+    expect(ref).to.deep.equal({ one: { two: { 3: { 4: 1234 } } } })
 
     pro(ref).one.two.tree = 123
 
-    expect(ref).toEqual({ one: { two: { 3: { 4: 1234 }, tree: 123 } } })
+    expect(ref).to.deep.equal({ one: { two: { 3: { 4: 1234 }, tree: 123 } } })
 
     pro(ref).one.two = undefined
 
-    expect(ref).toEqual({ one: { two: undefined } })
+    expect(ref).to.deep.equal({ one: { two: undefined } })
 
     delete pro(ref).one.two
 
-    expect(ref).toEqual({ one: {} })
+    expect(ref).to.deep.equal({ one: {} })
 
     pro(ref).one.two.three.four
 
-    expect(ref).toEqual({ one: { two: { three: { four: {} } } } })
+    expect(ref).to.deep.equal({ one: { two: { three: { four: {} } } } })
 
     pro(ref).one.two.three.four = 1234
 
-    expect(ref).toEqual({ one: { two: { three: { four: 1234 } } } })
+    expect(ref).to.deep.equal({ one: { two: { three: { four: 1234 } } } })
   }
 }