pepka 1.9.5 → 1.11.0

package/dist/bundle.cjs

@@ -83,6 +83,7 @@ const startsWithWith = (comparator) => curry2((start, s) => {
     return true;
 });
 
+const unsafe_props = { '__proto__': true, 'constructor': true, 'prototype': true };
 const undef = undefined;
 const nul = null;
 const inf = Infinity;
@@ -96,6 +97,8 @@ function isFunc(s) { return to(s) === 'function'; }
 const isStr = (s) => (to(s) === 'string');
 const isObj = (s) => (!isNull(s) && to(s) === 'object');
 const isNil = (s) => (isNull(s) || isUndef(s));
+const isSafe = (prop) => !(prop in unsafe_props);
+// TODO: add .then(), .finally() and .catch() to return QPromise.
 class QPromise extends Promise {
     oncancel;
     ff;
@@ -107,9 +110,7 @@ class QPromise extends Promise {
     }
     constructor(fn, oncancel = noop) {
         let _cancel_data = not_assigned;
-        super((ff, rj) => {
-            _cancel_data = fn(ff, rj);
-        });
+        super((ff, rj) => _cancel_data = fn(ff, rj));
         this.oncancel = oncancel;
         const set_cb = () => this._cancel_data = _cancel_data;
         // @ts-ignore-next
@@ -120,6 +121,7 @@ class QPromise extends Promise {
     }
 }
 
+const { isNaN } = Number;
 // It's faster that toUpperCase() !
 const caseMap = { u: 'U', b: 'B', n: 'N', s: 'S', f: 'F', o: 'O' };
 const symbol = Symbol();
@@ -130,7 +132,8 @@ const type = (s) => {
     const t = to(s);
     return t === 'object'
         ? isNull(s) ? 'Null' : (s.constructor?.name || cap_type(t))
-        : cap_type(t);
+        : t === 'number' && isNaN(s) ? 'NaN'
+            : cap_type(t);
 };
 const typeIs = curry2((t, s) => type(s) === t);
 const eq = curry2((a, b) => a === b);
@@ -167,35 +170,36 @@ const z = 0;
 const qappend = curry2((s, xs) => { xs.push(s); return xs; });
 const qassoc = curry3((prop, v, obj) => { obj[prop] = v; return obj; });
 const qreduce = curry3((fn, accum, arr) => arr.reduce(fn, accum));
-// strategy is for arrays: 1->clean, 2->merge, 3->push.
+// strategy is for arrays: 1->replace, 2->merge, 3->push.
 const mergeDeep$1 = (strategy) => curry2((o1, o2) => {
     for (let k in o2) {
-        switch (type(o2[k])) {
-            case 'Array':
-                if (strategy > 1 && type(o1[k]) === 'Array')
-                    switch (strategy) {
-                        case 2:
-                            const o1k = o1[k], o2k = o2[k];
-                            for (const i in o2k)
-                                if (o1k[i])
-                                    mergeDeep$1(strategy)(o1k[i], o2k[i]);
-                                else
-                                    o1k[i] = o2k[i];
-                            break;
-                        case 3: o1[k].push(...o2[k]);
+        if (isSafe(k))
+            switch (type(o2[k])) {
+                case 'Array':
+                    if (strategy > 1 && type(o1[k]) === 'Array')
+                        switch (strategy) {
+                            case 2:
+                                const o1k = o1[k], o2k = o2[k];
+                                for (const i in o2k)
+                                    if (o1k[i])
+                                        mergeDeep$1(strategy)(o1k[i], o2k[i]);
+                                    else
+                                        o1k[i] = o2k[i];
+                                break;
+                            case 3: o1[k].push(...o2[k]);
+                        }
+                    else
+                        o1[k] = o2[k];
+                    break;
+                case 'Object':
+                    if (type(o1[k]) === 'Object') {
+                        mergeDeep$1(strategy)(o1[k], o2[k]);
+                        break;
                     }
-                else
+                default:
                     o1[k] = o2[k];
-                break;
-            case 'Object':
-                if (type(o1[k]) === 'Object') {
-                    mergeDeep$1(strategy)(o1[k], o2[k]);
                     break;
-                }
-            default:
-                o1[k] = o2[k];
-                break;
-        }
+            }
     }
     return o1;
 });
@@ -345,6 +349,7 @@ const quniq = (xs) => {
 // Aliases.
 const qpush = qappend;
 
+const { assign } = Object;
 // TODO: over, lensProp, reduceAsync, propsEq is up to 20x slow due to deep equals.
 const take = (argN) => (...args) => args[argN];
 const ifElse = curry((cond, pipeYes, pipeNo, s) => cond(s) ? pipeYes(s) : pipeNo(s));
@@ -627,14 +632,14 @@ const memoize = curry2((keyGen, fn) => {
         return res;
     };
 });
-const mergeShallow = curry2((o1, o2) => Object.assign({}, o1, o2));
+const mergeShallow = curry2((o1, o2) => assign({}, o1, o2));
 const mergeDeep = curry2((a, b) => qmergeDeep(clone(a), b));
 const mergeDeepX = curry2((a, b) => qmergeDeepX(clone(a), b));
 const mergeDeepAdd = curry2((a, b) => qmergeDeepAdd(clone(a), b));
 /** @param prop string @param pipe(data[prop]) @param data any @returns data with prop over pipe. */
 const overProp = curry3((prop, pipe, data) => assoc(prop, pipe(data[prop]), data));
 /** mapKeys({ a: 'b' }, { a: 44 }) -> { b: 44 } */
-const mapKeys = curry2((keyMap, o) => qmapKeys(keyMap, Object.assign({}, o)));
+const mapKeys = curry2((keyMap, o) => qmapKeys(keyMap, assign({}, o)));
 const zip = curry2((a, b) => map((s, i) => [s, b[i]], a));
 const zipObj = curry2((a, b) => reduce((ac, s, i) => assoc(s, b[i], ac), {}, a));
 // TODO: Tuple curried functions to replace these `AnyFuncs`.

package/dist/bundle.mjs

@@ -81,6 +81,7 @@ const startsWithWith = (comparator) => curry2((start, s) => {
     return true;
 });
 
+const unsafe_props = { '__proto__': true, 'constructor': true, 'prototype': true };
 const undef = undefined;
 const nul = null;
 const inf = Infinity;
@@ -94,6 +95,8 @@ function isFunc(s) { return to(s) === 'function'; }
 const isStr = (s) => (to(s) === 'string');
 const isObj = (s) => (!isNull(s) && to(s) === 'object');
 const isNil = (s) => (isNull(s) || isUndef(s));
+const isSafe = (prop) => !(prop in unsafe_props);
+// TODO: add .then(), .finally() and .catch() to return QPromise.
 class QPromise extends Promise {
     oncancel;
     ff;
@@ -105,9 +108,7 @@ class QPromise extends Promise {
     }
     constructor(fn, oncancel = noop) {
         let _cancel_data = not_assigned;
-        super((ff, rj) => {
-            _cancel_data = fn(ff, rj);
-        });
+        super((ff, rj) => _cancel_data = fn(ff, rj));
         this.oncancel = oncancel;
         const set_cb = () => this._cancel_data = _cancel_data;
         // @ts-ignore-next
@@ -118,6 +119,7 @@ class QPromise extends Promise {
     }
 }
 
+const { isNaN } = Number;
 // It's faster that toUpperCase() !
 const caseMap = { u: 'U', b: 'B', n: 'N', s: 'S', f: 'F', o: 'O' };
 const symbol = Symbol();
@@ -128,7 +130,8 @@ const type = (s) => {
     const t = to(s);
     return t === 'object'
         ? isNull(s) ? 'Null' : (s.constructor?.name || cap_type(t))
-        : cap_type(t);
+        : t === 'number' && isNaN(s) ? 'NaN'
+            : cap_type(t);
 };
 const typeIs = curry2((t, s) => type(s) === t);
 const eq = curry2((a, b) => a === b);
@@ -165,35 +168,36 @@ const z = 0;
 const qappend = curry2((s, xs) => { xs.push(s); return xs; });
 const qassoc = curry3((prop, v, obj) => { obj[prop] = v; return obj; });
 const qreduce = curry3((fn, accum, arr) => arr.reduce(fn, accum));
-// strategy is for arrays: 1->clean, 2->merge, 3->push.
+// strategy is for arrays: 1->replace, 2->merge, 3->push.
 const mergeDeep$1 = (strategy) => curry2((o1, o2) => {
     for (let k in o2) {
-        switch (type(o2[k])) {
-            case 'Array':
-                if (strategy > 1 && type(o1[k]) === 'Array')
-                    switch (strategy) {
-                        case 2:
-                            const o1k = o1[k], o2k = o2[k];
-                            for (const i in o2k)
-                                if (o1k[i])
-                                    mergeDeep$1(strategy)(o1k[i], o2k[i]);
-                                else
-                                    o1k[i] = o2k[i];
-                            break;
-                        case 3: o1[k].push(...o2[k]);
+        if (isSafe(k))
+            switch (type(o2[k])) {
+                case 'Array':
+                    if (strategy > 1 && type(o1[k]) === 'Array')
+                        switch (strategy) {
+                            case 2:
+                                const o1k = o1[k], o2k = o2[k];
+                                for (const i in o2k)
+                                    if (o1k[i])
+                                        mergeDeep$1(strategy)(o1k[i], o2k[i]);
+                                    else
+                                        o1k[i] = o2k[i];
+                                break;
+                            case 3: o1[k].push(...o2[k]);
+                        }
+                    else
+                        o1[k] = o2[k];
+                    break;
+                case 'Object':
+                    if (type(o1[k]) === 'Object') {
+                        mergeDeep$1(strategy)(o1[k], o2[k]);
+                        break;
                     }
-                else
+                default:
                     o1[k] = o2[k];
-                break;
-            case 'Object':
-                if (type(o1[k]) === 'Object') {
-                    mergeDeep$1(strategy)(o1[k], o2[k]);
                     break;
-                }
-            default:
-                o1[k] = o2[k];
-                break;
-        }
+            }
     }
     return o1;
 });
@@ -343,6 +347,7 @@ const quniq = (xs) => {
 // Aliases.
 const qpush = qappend;
 
+const { assign } = Object;
 // TODO: over, lensProp, reduceAsync, propsEq is up to 20x slow due to deep equals.
 const take = (argN) => (...args) => args[argN];
 const ifElse = curry((cond, pipeYes, pipeNo, s) => cond(s) ? pipeYes(s) : pipeNo(s));
@@ -625,14 +630,14 @@ const memoize = curry2((keyGen, fn) => {
         return res;
     };
 });
-const mergeShallow = curry2((o1, o2) => Object.assign({}, o1, o2));
+const mergeShallow = curry2((o1, o2) => assign({}, o1, o2));
 const mergeDeep = curry2((a, b) => qmergeDeep(clone(a), b));
 const mergeDeepX = curry2((a, b) => qmergeDeepX(clone(a), b));
 const mergeDeepAdd = curry2((a, b) => qmergeDeepAdd(clone(a), b));
 /** @param prop string @param pipe(data[prop]) @param data any @returns data with prop over pipe. */
 const overProp = curry3((prop, pipe, data) => assoc(prop, pipe(data[prop]), data));
 /** mapKeys({ a: 'b' }, { a: 44 }) -> { b: 44 } */
-const mapKeys = curry2((keyMap, o) => qmapKeys(keyMap, Object.assign({}, o)));
+const mapKeys = curry2((keyMap, o) => qmapKeys(keyMap, assign({}, o)));
 const zip = curry2((a, b) => map((s, i) => [s, b[i]], a));
 const zipObj = curry2((a, b) => reduce((ac, s, i) => assoc(s, b[i], ac), {}, a));
 // TODO: Tuple curried functions to replace these `AnyFuncs`.

package/package.json

@@ -41,7 +41,7 @@
     "prod": "npm run gentypes && npm run prod:es && npm run prod:cjs",
     "all": "npm run dev && npm run prod"
   },
-  "version": "1.9.5",
+  "version": "1.11.0",
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.2",
     "@rollup/plugin-node-resolve": "^16.0.3",

package/src/common.ts

@@ -1,6 +1,7 @@
 import { curry2 } from "./curry"
 import { is_typed_arr } from "./internal"
 import { isNull, isStr, to } from "./utils"
+const {isNaN} = Number
 
 // It's faster that toUpperCase() !
 const caseMap = { u: 'U', b: 'B', n: 'N', s: 'S', f: 'F', o: 'O' }
@@ -13,6 +14,7 @@ export const type = (s: any): string => {
   const t = to(s)
   return t==='object'
     ? isNull(s) ? 'Null' : (s.constructor?.name||cap_type(t))
+    : t==='number'&&isNaN(s) ? 'NaN'
     : cap_type(t)
 }
 export const typeIs = curry2((t: string, s: any) => type(s)===t)

package/src/curry.ts

@@ -68,7 +68,7 @@ export type Curried2<p0, p1, ReturnT> = {
 }
 
 type Func2 = (a: any, b: any) => any
-const zero = 0, one = 1
+const zero = 0
 export function curry2<Func extends Func2>(fn: Func) {
   type p0 = Parameters<Func>[0]
   type p1 = Parameters<Func>[1]

package/src/quick.ts

@@ -1,7 +1,7 @@
 import { includes, length, type } from "./common"
 import { curry2, curry3 } from "./curry"
 import { AnyFunc, AnyObject, Reducer } from "./types"
-import { inf, isArray, isFunc, isNil, isNum, isObj } from "./utils"
+import { inf, isArray, isFunc, isNil, isNum, isObj, isSafe } from "./utils"
 const {min} = Math
 const z = 0
 /* qflat, qflatShallow, qreduceAsync */
@@ -9,10 +9,10 @@ const z = 0
 export const qappend = curry2((s: any, xs: any[]) => {xs.push(s); return xs})
 export const qassoc = curry3((prop: string, v: any, obj: AnyObject) => { obj[prop] = v; return obj })
 export const qreduce = curry3(<T>(fn: Reducer, accum: any, arr: T[]) => arr.reduce(fn, accum))
-// strategy is for arrays: 1->clean, 2->merge, 3->push.
+// strategy is for arrays: 1->replace, 2->merge, 3->push.
 const mergeDeep = (strategy: 1|2|3) => curry2((o1: AnyObject, o2: AnyObject): AnyObject => {
   for(let k in o2) {
-    switch(type(o2[k])) {
+    if(isSafe(k)) switch(type(o2[k])) {
       case 'Array':
         if(strategy>1 && type(o1[k])==='Array')
           switch(strategy) {

package/src/safe.ts

@@ -5,6 +5,7 @@ import { AnyArray, IndexesOfArray, Split } from './internal_types'
 import { qappend, qfilter, qfreeze, qfreezeShallow, qmapKeys, qmapObj, qmergeDeep, qmergeDeepAdd, qmergeDeepX, qreduce } from './quick'
 import { AnyFunc, AnyObject, Composed, Cond, Reducer } from './types'
 import { inf, isArray, isFunc, isNil, isNum, isObj, undef } from './utils'
+const {assign} = Object
 // TODO: over, lensProp, reduceAsync, propsEq is up to 20x slow due to deep equals.
 
 export const take = (argN: number) => (...args: any[]) => args[argN]
@@ -410,7 +411,7 @@ export const memoize = curry2(<Args extends any[]>(
 })
 export const mergeShallow = curry2(
   (o1: AnyObject, o2: AnyObject): AnyObject =>
-    Object.assign({}, o1, o2)
+    assign({}, o1, o2)
 )
 export const mergeDeep = curry2(
   (a: AnyObject, b: AnyObject) => qmergeDeep(clone(a), b) as AnyObject
@@ -431,7 +432,7 @@ export const mapKeys = curry2(
   (
     keyMap: {[oldKey: string]: string | AnyFunc},
     o: AnyObject
-  ) => qmapKeys(keyMap, Object.assign({}, o))
+  ) => qmapKeys(keyMap, assign({}, o))
 )
 export const zip = curry2(
   <T1 = any, T2 = any>(a: T1[], b: T2[]) => map((s: T1, i: number) => [s, b[i]], a)

package/src/utils.ts

@@ -1,6 +1,7 @@
 import { noop } from "./safe"
 import { AnyFunc, AnyObject } from "./types"
 
+const unsafe_props = {'__proto__': true, 'constructor': true, 'prototype': true}
 export const undef = undefined
 export const nul = null
 export const inf = Infinity
@@ -16,7 +17,8 @@ export function isFunc(s: any) { return to(s)==='function' }
 export const isStr = <T extends any>(s: T) => (to(s)==='string') as T extends string ? true : false
 export const isObj = <T extends any>(s: T) => (!isNull(s) && to(s)==='object') as T extends AnyObject ? true : false
 export const isNil = <T extends any>(s: T) => (isNull(s) || isUndef(s)) as T extends (null|undefined) ? true : false
-
+export const isSafe = (prop: string) => !(prop in unsafe_props)
+// TODO: add .then(), .finally() and .catch() to return QPromise.
 export class QPromise<T> extends Promise<T> {
   private ff: AnyFunc
   private _cancel_data: any
@@ -26,9 +28,7 @@ export class QPromise<T> extends Promise<T> {
   }
   constructor(fn: AnyFunc<any, [AnyFunc, AnyFunc, AnyFunc?]>, private oncancel = noop) {
     let _cancel_data: any = not_assigned
-    super((ff, rj) => {
-      _cancel_data = fn(ff, rj)
-    })
+    super((ff, rj) => _cancel_data = fn(ff, rj))
     const set_cb = () => this._cancel_data=_cancel_data
     // @ts-ignore-next
     if(_cancel_data!==not_assigned) set_cb()