[Bug] getInst() function is getting mis-optimized for a worker with r…

…ollup #302
nevware21 · Sep 21, 2024 · 2424402 · 2424402
1 parent 1fedb77
commit 2424402
Show file tree

Hide file tree

Showing 15 changed files with 53 additions and 29 deletions.
diff --git a/lib/src/array/slice.ts b/lib/src/array/slice.ts
@@ -6,7 +6,7 @@
  * Licensed under the MIT license.
  */
 
-import { ArrSlice, CALL } from "../internal/constants";
+import { ArrSlice, CALL, NULL_VALUE } from "../internal/constants";
 
 /**
  * The arrSlice() method returns a shallow copy of a portion of an array into a new array object
@@ -52,5 +52,5 @@ import { ArrSlice, CALL } from "../internal/constants";
  * ```
  */
 export function arrSlice<T>(theArray: ArrayLike<T>, start?: number, end?: number): T[] {
-    return ((theArray && theArray["slice"]) || ArrSlice).apply(theArray, ArrSlice[CALL](arguments, 1));
+    return ((theArray ? theArray["slice"] : NULL_VALUE) || ArrSlice).apply(theArray, ArrSlice[CALL](arguments, 1));
 }
diff --git a/lib/src/funcs/readArgs.ts b/lib/src/funcs/readArgs.ts
@@ -91,7 +91,11 @@ export function readArgs<T = any>(theArgs: ArrayLike<T> | Iterable<T>, start?: n
         // IArgument is both ArrayLike and an iterable, so prefering to treat it as
         // an array for performance
         !_iterSymbol && (_iterSymbol = createCachedValue(hasSymbol() && getKnownSymbol(WellKnownSymbols.iterator)));
-        let iterFn = _iterSymbol.v && theArgs[_iterSymbol.v];
+        let iterFn: any;
+        if (_iterSymbol.v) {
+            iterFn = theArgs[_iterSymbol.v];
+        }
+
         if (iterFn) {
             let values: T[] = [];
             let from = (start === UNDEF_VALUE || start < 0) ? 0 : start;

diff --git a/lib/src/helpers/base.ts b/lib/src/helpers/base.ts
@@ -358,7 +358,7 @@ export function isPrimitive(value: any): value is string | number | bigint | boo
 export function isPrimitiveType(theType: string): boolean {
     !_primitiveTypes && (_primitiveTypes = [ "string", "number", "boolean", UNDEFINED, "symbol", "bigint" ]);
 
-    return theType !== OBJECT && _primitiveTypes.indexOf(theType) !== -1;
+    return !!(theType !== OBJECT && _primitiveTypes.indexOf(theType) !== -1);
 }
 
 /**

diff --git a/lib/src/helpers/diagnostics.ts b/lib/src/helpers/diagnostics.ts
@@ -75,7 +75,7 @@ export function dumpObj(object: any, format?: boolean | number): string {
 
     try {
         propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? (((typeof format as unknown) === "number") ? format as number : 4) : UNDEF_VALUE);
-        propertyValueDump = (propertyValueDump && propertyValueDump.replace(/"(\w+)"\s*:\s{0,1}/g, "$1: ")) || asString(object);
+        propertyValueDump = (propertyValueDump ? propertyValueDump.replace(/"(\w+)"\s*:\s{0,1}/g, "$1: ") : NULL_VALUE) || asString(object);
     } catch(e) {
         // Unable to convert object (probably circular)
         propertyValueDump = " - " + dumpObj(e, format);

diff --git a/lib/src/helpers/environment.ts b/lib/src/helpers/environment.ts
@@ -31,7 +31,9 @@ export function _getGlobalInstFn<T>(getFn: (...args: unknown[]) => T, theArgs?:
     let cachedValue: ICachedValue<T>;
     return function() {
         !_globalLazyTestHooks && _initTestHooks();
-        (!cachedValue || _globalLazyTestHooks.lzy) && (cachedValue = createCachedValue(safe(getFn, theArgs).v));
+        if (!cachedValue || _globalLazyTestHooks.lzy) {
+            cachedValue = createCachedValue(safe(getFn, theArgs).v);
+        }
 
         return cachedValue.v;
     }
@@ -86,10 +88,11 @@ export function lazySafeGetInst<T>(name: string | number | symbol) : ILazyValue<
  * @param useCached - [Optional] used for testing to bypass the cached lookup, when `true` this will
  * cause the cached global to be reset.
  */
-/*#__NO_SIDE_EFFECTS__*/
 export function getGlobal(useCached?: boolean): Window {
     !_globalLazyTestHooks && _initTestHooks();
-    (!_cachedGlobal || useCached === false || _globalLazyTestHooks.lzy) && (_cachedGlobal = createCachedValue(safe(_getGlobalValue).v || NULL_VALUE));
+    if (!_cachedGlobal || useCached === false || _globalLazyTestHooks.lzy) {
+        _cachedGlobal = createCachedValue(safe(_getGlobalValue).v || NULL_VALUE);
+    }
 
     return _cachedGlobal.v;
 }
@@ -117,15 +120,25 @@ export function getGlobal(useCached?: boolean): Window {
  */
 /*#__NO_SIDE_EFFECTS__*/
 export function getInst<T>(name: string | number | symbol, useCached?: boolean): T | null {
-    const gbl = (!_cachedGlobal || useCached === false) ? getGlobal(useCached) : _cachedGlobal.v;
+    let gbl: any;
+    if (!_cachedGlobal || useCached === false) {
+        gbl = getGlobal(useCached);
+    } else {
+        gbl = _cachedGlobal.v;
+    }
+
     if (gbl && gbl[name]) {
         return gbl[name] as T;
     }
 
     // Test workaround, for environments where <global>.window (when global == window) doesn't return the base window
     if (name === WINDOW) {
         // tslint:disable-next-line: no-angle-bracket-type-assertion
-        return <any>getWindow() as T;
+        try {
+            return window as T;
+        } catch (e) {
+            // Ignore
+        }
     }
 
     return NULL_VALUE;

diff --git a/lib/src/helpers/perf.ts b/lib/src/helpers/perf.ts
@@ -39,7 +39,10 @@ export function hasPerformance(): boolean {
 /*#__NO_SIDE_EFFECTS__*/
 export function getPerformance(): Performance {
     !_globalLazyTestHooks && _initTestHooks();
-    (!_perf || _globalLazyTestHooks.lzy) && (_perf = createCachedValue(safe(getInst<Performance>, ["performance"]).v));
+    if (!_perf || _globalLazyTestHooks.lzy) {
+        _perf = createCachedValue(safe(getInst<Performance>, ["performance"]).v);
+    }
+
     return _perf.v;
 }
 

diff --git a/lib/src/internal/unwrapFunction.ts b/lib/src/internal/unwrapFunction.ts
@@ -9,7 +9,7 @@
 import { dumpObj } from "../helpers/diagnostics";
 import { throwTypeError } from "../helpers/throw";
 import { asString } from "../string/as_string";
-import { ArrSlice, CALL } from "./constants";
+import { ArrSlice, CALL, NULL_VALUE } from "./constants";
 
 /**
  * @internal
@@ -44,10 +44,10 @@ export const _unwrapFunction:<R, T>(funcName: keyof T, clsProto: T) => <T>(this:
  */
 /*#__NO_SIDE_EFFECTS__*/
 export function _unwrapFunctionWithPoly<T, P extends (...args: any) => any>(funcName: keyof T, clsProto?: T, polyFunc?: P) {
-    let clsFn = clsProto && clsProto[funcName];
+    let clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
 
     return function(thisArg: any): ReturnType<P> {
-        let theFunc = (thisArg && thisArg[funcName]) || clsFn;
+        let theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || clsFn;
         if (theFunc || polyFunc) {
             let theArgs = arguments;
             return ((theFunc || polyFunc) as Function).apply(thisArg, theFunc ? ArrSlice[CALL](theArgs, 1) : theArgs);

diff --git a/lib/src/iterator/create.ts b/lib/src/iterator/create.ts
@@ -196,7 +196,9 @@ export function createIterator<T>(ctx: CreateIteratorContext<T>): Iterator<T> {
     }
 
     function _next(): IteratorResult<T> {
-        isDone = isDone || (ctx.n ? ctx.n(arguments) : true);
+        if (!isDone) {
+            isDone = (ctx.n ? ctx.n(arguments) : true);
+        }
 
         let result  = {
             done: isDone

diff --git a/lib/src/iterator/forOf.ts b/lib/src/iterator/forOf.ts
@@ -6,7 +6,6 @@
  * Licensed under the MIT license.
  */
 
-import { fnCall } from "../funcs/funcs";
 import { ICachedValue, createCachedValue } from "../helpers/cache";
 import { CALL, NULL_VALUE, UNDEF_VALUE } from "../internal/constants";
 import { getKnownSymbol } from "../symbol/symbol";
@@ -60,7 +59,7 @@ export function iterForOf<T>(iter: Iterator<T> | Iterable<T>, callbackfn: (value
     if (iter) {
         if (!isIterator(iter)) {
             !_iterSymbol && (_iterSymbol = createCachedValue(getKnownSymbol(WellKnownSymbols.iterator)));
-            iter = iter[_iterSymbol.v] ? iter[_iterSymbol.v]() : null;
+            iter = iter[_iterSymbol.v] ? iter[_iterSymbol.v]() : NULL_VALUE;
         }
 
         if (isIterator(iter)) {

diff --git a/lib/src/object/copy.ts b/lib/src/object/copy.ts
@@ -118,11 +118,13 @@ function _deepCopy<T>(visitMap: _RecursiveVisitMap[], value: T, ctx: _DeepCopyCo
 
     const theType = typeof value;
     let isPlain = false;
-    let isPrim = false;
-    if (value && theType === OBJECT) {
-        isPlain = isPlainObject(value);
-    } else {
-        isPrim = value === NULL_VALUE || isPrimitiveType(theType);
+    let isPrim = value === NULL_VALUE;
+    if (!isPrim) {
+        if (value && theType === OBJECT) {
+            isPlain = isPlainObject(value);
+        } else {
+            isPrim = isPrimitiveType(theType);
+        }
     }
 
     let details: IObjDeepCopyHandlerDetails = {

diff --git a/lib/src/object/is_plain_object.ts b/lib/src/object/is_plain_object.ts
@@ -81,7 +81,7 @@ export function isPlainObject(value: any): value is object {
                     proto = proto[CONSTRUCTOR]
                 }
 
-                result = proto && typeof proto === FUNCTION && _fnToString[CALL](proto) === _objCtrFnString;
+                result = !!(proto && typeof proto === FUNCTION && _fnToString[CALL](proto) === _objCtrFnString);
             }
         } catch (ex) {
             // Something went wrong, so it's not an object we are playing with

diff --git a/lib/src/polyfills/split.ts b/lib/src/polyfills/split.ts
@@ -6,6 +6,7 @@
  * Licensed under the MIT license.
  */
 
+import { UNDEF_VALUE } from "../internal/constants";
 import { getKnownSymbol } from "../symbol/symbol";
 import { WellKnownSymbols } from "../symbol/well_known";
 
@@ -55,7 +56,7 @@ import { WellKnownSymbols } from "../symbol/well_known";
  */
 /*#__NO_SIDE_EFFECTS__*/
 export function polyStrSymSplit(value: string, splitter: { [Symbol.split](string: string, limit?: number): string[]; }, limit?: number): string[] {
-    let splitFn: (string: string, limit?: number) => string[] = splitter && splitter[getKnownSymbol(WellKnownSymbols.split)];
+    let splitFn: (string: string, limit?: number) => string[] = splitter ?(splitter as any)[getKnownSymbol(WellKnownSymbols.split)] : UNDEF_VALUE;
 
     return splitFn ? splitFn(value, limit) : [ value ];
 }
diff --git a/lib/src/string/ends_with.ts b/lib/src/string/ends_with.ts
@@ -38,7 +38,7 @@ export function polyStrEndsWith(value: string, searchString: string, length?: nu
     }
 
     let searchValue = isString(searchString) ? searchString : asString(searchString);
-    let end = !isUndefined(length) && length < value[LENGTH] ? length : value[LENGTH];
+    let end = (!isUndefined(length) && length < value[LENGTH]) ? length : value[LENGTH];
 
     return strSubstring(value, end - searchValue[LENGTH], end) === searchValue;
 }
diff --git a/lib/src/string/split.ts b/lib/src/string/split.ts
@@ -6,7 +6,7 @@
  * Licensed under the MIT license.
  */
 
-import { StrProto } from "../internal/constants";
+import { NULL_VALUE, StrProto } from "../internal/constants";
 import { _unwrapFunction, _unwrapFunctionWithPoly } from "../internal/unwrapFunction";
 import { polyStrSymSplit } from "../polyfills/split";
 import { hasSymbol } from "../symbol/symbol";
@@ -87,4 +87,4 @@ export const strSplit: (value: string, separator: string | RegExp, limit?: numbe
  * console.log(strSymSplit(myString, splitByNumber)); // [ "a", "bc", "c5d", "e", "f" ]
  * ```
  */
-export const strSymSplit: (value: string, splitter: { [Symbol.split](string: string, limit?: number): string[]; }, limit?: number) => string[] = (/*#__PURE__*/_unwrapFunctionWithPoly("split", StrProto, !hasSymbol() ? polyStrSymSplit : null));
+export const strSymSplit: (value: string, splitter: { [Symbol.split](string: string, limit?: number): string[]; }, limit?: number) => string[] = (/*#__PURE__*/_unwrapFunctionWithPoly("split", StrProto, !hasSymbol() ? polyStrSymSplit : NULL_VALUE));
diff --git a/package.json b/package.json
@@ -159,8 +159,8 @@
     "devDependencies": {
         "@istanbuljs/nyc-config-typescript": "^1.0.2",
         "@microsoft/api-extractor": "^7.34.4",
-        "@nevware21/grunt-eslint-ts": "0.5.0",
-        "@nevware21/grunt-ts-plugin": "0.5.0",
+        "@nevware21/grunt-eslint-ts": "^0.5.1",
+        "@nevware21/grunt-ts-plugin": "^0.5.1",
         "@nevware21/tripwire-chai": ">= 0.1.1 && < 2.0.0",
         "@rollup/plugin-commonjs": "^26.0.1",
         "@rollup/plugin-json": "^6.0.0",