STASH polyfills in dev-utils

Author: lobsterkatie

packages/dev-utils/.gitignore

@@ -0,0 +1 @@
+!test/jsPolyfills/originals.d.ts

packages/dev-utils/jest.config.js

@@ -1 +1,9 @@
-module.exports = require('../../jest/jest.config.js');
+const baseConfig = require('../../jest/jest.config.js');
+
+module.exports = {
+  ...baseConfig,
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+    '^.+\\.js$': 'ts-jest',
+  },
+};

packages/dev-utils/package.json

@@ -25,7 +25,7 @@
     "build:dev": "run-s build",
     "build:es5": "yarn build:cjs # *** backwards compatibility - remove in v7 ***",
     "build:esm": "tsc -p tsconfig.esm.json",
-    "build:rollup": "rollup -c rollup.npm.config.js",
+    "build:rollup": "yarn rollup -c rollup.npm.config.js && cp src/jsPolyfills/README.md build/cjs/jsPolyfills && cp src/jsPolyfills/README.md build/esm/jsPolyfills",
     "build:types": "tsc -p tsconfig.types.json",
     "build:watch": "run-p build:cjs:watch build:esm:watch build:types:watch",
     "build:cjs:watch": "tsc -p tsconfig.cjs.json --watch",

packages/dev-utils/src/index.ts

@@ -1 +1,3 @@
+export * as jsPolyfills from './jsPolyfills';
+
 // empty placeholder

rollup/jsPolyfills/README.md renamed to packages/dev-utils/src/jsPolyfills/README.md

@@ -0,0 +1,25 @@
+import { RequireResult } from './types';
+/**
+ * Adds a `default` property to CJS modules which aren't the result of transpilation from ESM modules.
+ *
+ * Adapted from Rollup (https://github.com/rollup/rollup)
+ *
+ * @param requireResult The result of calling `require` on a module
+ * @returns Either `requireResult` or a copy of `requireResult` with an added self-referential `default` property
+ */
+export function _interopNamespace(requireResult: RequireResult): RequireResult {
+  return requireResult.__esModule ? requireResult : { ...requireResult, default: requireResult };
+}
+
+// Rollup version (with `output.externalLiveBindings` and `output.freeze` both set to false)
+// function _interopNamespace(e) {
+//   if (e && e.__esModule) return e;
+//   var n = Object.create(null);
+//   if (e) {
+//     for (var k in e) {
+//       n[k] = e[k];
+//     }
+//   }
+//   n["default"] = e;
+//   return n;
+// }

rollup/jsPolyfills/_asyncNullishCoalesce.js renamed to packages/dev-utils/src/jsPolyfills/_asyncNullishCoalesce.js

@@ -0,0 +1,25 @@
+/**
+ * Polyfill for the nullish coalescing operator (`??`).
+ *
+ * Note that the RHS is wrapped in a function so that if it's a computed value, that evaluation won't happen unless the
+ * LHS evaluates to a nullish value, to mimic the operator's short-circuiting behavior.
+ *
+ * Adapted from Sucrase (https://github.com/alangpierce/sucrase)
+ *
+ * @param lhs The value of the expression to the left of the `??`
+ * @param rhsFn A function returning the value of the expression to the right of the `??`
+ * @returns The LHS value, unless it's `null` or `undefined`, in which case, the RHS value
+ */
+export function _nullishCoalesce(lhs: unknown, rhsFn: () => unknown): unknown {
+  // by checking for loose equality to `null`, we catch both `null` and `undefined`
+  return lhs != null ? lhs : rhsFn();
+}
+
+// Sucrase version:
+// function _nullishCoalesce(lhs, rhsFn) {
+//   if (lhs != null) {
+//     return lhs;
+//   } else {
+//     return rhsFn();
+//   }
+// }

rollup/jsPolyfills/_asyncOptionalChain.js renamed to packages/dev-utils/src/jsPolyfills/_asyncOptionalChain.js

@@ -1,7 +1,13 @@
 // adapted from Sucrase (https://github.com/alangpierce/sucrase)
 
-export function _optionalChain(ops) {
-  let lastAccessLHS = undefined;
+/**
+ *
+ *
+ * @param ops
+ * @returns
+ */
+export function _optionalChain(ops: any[]): any {
+  let lastAccessLHS: any = undefined;
   let value = ops[0];
   let i = 1;
   while (i < ops.length) {
@@ -17,7 +23,9 @@ export function _optionalChain(ops) {
       lastAccessLHS = value;
       value = fn(value);
     } else if (op in ['call', 'optionalCall']) {
-      value = fn((...args) => value.call(lastAccessLHS, ...args));
+      // TODO !!!!!!!!
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      value = fn((...args: unknown[]) => value.call(lastAccessLHS, ...args));
       lastAccessLHS = undefined;
     }
   }

rollup/jsPolyfills/_asyncOptionalChainDelete.js renamed to packages/dev-utils/src/jsPolyfills/_asyncOptionalChainDelete.js

@@ -0,0 +1,14 @@
+export type { RequireResult } from './types';
+
+// export { _asyncNullishCoalesce } from './_asyncNullishCoalesce';
+// export { _asyncOptionalChain } from './_asyncOptionalChain';
+// export { _asyncOptionalChainDelete } from './_asyncOptionalChainDelete';
+// export { _createNamedExportFrom } from './_createNamedExportFrom';
+// export { _createStarExport } from './_createStarExport';
+// export { _interopDefault } from './_interopDefault';
+export { _interopNamespace } from './_interopNamespace';
+// export { _interopRequireDefault } from './_interopRequireDefault';
+// export { _interopRequireWildcard } from './_interopRequireWildcard';
+export { _nullishCoalesce } from './_nullishCoalesce';
+export { _optionalChain } from './_optionalChain';
+// export { _optionalChainDelete } from './_optionalChainDelete';

rollup/jsPolyfills/_createNamedExportFrom.js renamed to packages/dev-utils/src/jsPolyfills/_createNamedExportFrom.js

@@ -0,0 +1,6 @@
+// export type RequireResult = Record<string, unknown> | (((...args: unknown[]) => unknown) & Record<string, unknown>);
+type GenericObject = { [key: string]: unknown };
+type GenericFunction = (...args: unknown[]) => unknown;
+
+export type RequireResult = GenericObject | (GenericFunction & GenericObject);
+// export type RequireResult = GenericObject | GenericFunction | (GenericFunction & GenericObject);

rollup/jsPolyfills/_createStarExport.js renamed to packages/dev-utils/src/jsPolyfills/_createStarExport.js

@@ -0,0 +1,30 @@
+import { _interopNamespace, RequireResult } from '../../src/jsPolyfills';
+import { _interopNamespace as _interopNamespaceOrig } from './originals';
+
+describe('_interopNamespace', () => {
+  it('returns the same result as the original', () => {
+    const withESModuleFlag = { __esModule: true, charlie: 'goofy', maisey: 'silly' };
+    const namedExports = { charlie: 'goofy', maisey: 'silly' };
+    const withNonEnumerableProp = { charlie: 'goofy', maisey: 'silly' };
+    Object.defineProperty(withNonEnumerableProp, 'hiddenProp', {
+      value: 'shhhhhhhh',
+      // this is the default, but including it here anyway for clarity
+      enumerable: false,
+    });
+    const withDefaultExport = { default: () => 'dogs are great', charlie: 'goofy', maisey: 'silly' };
+    const withOnlyDefaultExport = { default: () => 'dogs are great' };
+    const exportsEquals = () => 'dogs are great';
+    const exportsEqualsWithDefault = () => 'dogs are great';
+    exportsEqualsWithDefault.default = exportsEqualsWithDefault;
+
+    expect(_interopNamespace(withESModuleFlag)).toEqual(_interopNamespaceOrig(withESModuleFlag));
+    expect(_interopNamespace(namedExports)).toEqual(_interopNamespaceOrig(namedExports));
+    expect(_interopNamespace(withNonEnumerableProp)).toEqual(_interopNamespaceOrig(withNonEnumerableProp));
+    expect(_interopNamespace(withDefaultExport)).toEqual(_interopNamespaceOrig(withDefaultExport));
+    expect(_interopNamespace(withOnlyDefaultExport)).toEqual(_interopNamespaceOrig(withOnlyDefaultExport));
+    expect(_interopNamespace(exportsEquals as RequireResult)).toEqual(_interopNamespaceOrig(exportsEquals));
+    expect(_interopNamespace(exportsEqualsWithDefault as unknown as RequireResult)).toEqual(
+      _interopNamespaceOrig(exportsEqualsWithDefault),
+    );
+  });
+});

rollup/jsPolyfills/_interopDefault.js renamed to packages/dev-utils/src/jsPolyfills/_interopDefault.js

@@ -0,0 +1,18 @@
+// NOTE: Unlike other types files, this is NOT auto-generated by our build scripts. Since these functions are the
+// originals of functions we adapted from Rollup and Sucrase, there's no reason they should ever change, but if they do,
+// this file needs to be regenerated, by running
+//   `yarn tsc --allowJs --skipLibCheck --declaration --emitDeclarationOnly test/jsPolyfills/originals.js`
+// (Keep in mind that that will clobber this note, so make sure to undo that part of the change.)
+
+export function _asyncNullishCoalesce(lhs: any, rhsFn: any): Promise<any>;
+export function _asyncOptionalChain(ops: any): Promise<any>;
+export function _asyncOptionalChainDelete(ops: any): Promise<any>;
+export function createNamedExportFrom(obj: any, localName: any, importedName: any): void;
+export function _createStarExport(obj: any): void;
+export function _interopDefault(e: any): any;
+export function _interopNamespace(e: any): any;
+export function _interopRequireDefault(obj: any): any;
+export function _interopRequireWildcard(obj: any): any;
+export function _nullishCoalesce(lhs: any, rhsFn: any): any;
+export function _optionalChain(ops: any): any;
+export function _optionalChainDelete(ops: any): any;

packages/dev-utils/src/jsPolyfills/_interopNamespace.ts

@@ -0,0 +1,140 @@
+// Originals of the jsPolyfills from Sucrase and Rollup we use (which we have adapted in various ways), preserved here for testing, to prove that
+// the modified versions do the same thing the originals do.
+
+// From Sucrase
+export async function _asyncNullishCoalesce(lhs, rhsFn) {
+  if (lhs != null) {
+    return lhs;
+  } else {
+    return await rhsFn();
+  }
+}
+
+// From Sucrase
+export async function _asyncOptionalChain(ops) {
+  let lastAccessLHS = undefined;
+  let value = ops[0];
+  let i = 1;
+  while (i < ops.length) {
+    const op = ops[i];
+    const fn = ops[i + 1];
+    i += 2;
+    if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {
+      return undefined;
+    }
+    if (op === 'access' || op === 'optionalAccess') {
+      lastAccessLHS = value;
+      value = await fn(value);
+    } else if (op === 'call' || op === 'optionalCall') {
+      value = await fn((...args) => value.call(lastAccessLHS, ...args));
+      lastAccessLHS = undefined;
+    }
+  }
+  return value;
+}
+
+// From Sucrase
+export async function _asyncOptionalChainDelete(ops) {
+  const result = await _asyncOptionalChain(ops);
+  // by checking for loose equality to `null`, we catch both `null` and `undefined`
+  return result == null ? true : result;
+}
+
+// From Sucrase
+export function createNamedExportFrom(obj, localName, importedName) {
+  Object.defineProperty(exports, localName, { enumerable: true, get: () => obj[importedName] });
+}
+
+// From Sucrase
+export function _createStarExport(obj) {
+  Object.keys(obj)
+    .filter(key => key !== 'default' && key !== '__esModule')
+    .forEach(key => {
+      // eslint-disable-next-line no-prototype-builtins
+      if (exports.hasOwnProperty(key)) {
+        return;
+      }
+      Object.defineProperty(exports, key, { enumerable: true, get: () => obj[key] });
+    });
+}
+
+// From Rollup
+export function _interopDefault(e) {
+  return e && e.__esModule ? e['default'] : e;
+}
+
+// From Rollup
+export function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    // eslint-disable-next-line guard-for-in
+    for (var k in e) {
+      n[k] = e[k];
+    }
+  }
+  n['default'] = e;
+  return n;
+}
+
+// From Sucrase
+export function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+
+// From Sucrase
+export function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  } else {
+    var newObj = {};
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          newObj[key] = obj[key];
+        }
+      }
+    }
+    newObj.default = obj;
+    return newObj;
+  }
+}
+
+// From Sucrase
+export function _nullishCoalesce(lhs, rhsFn) {
+  if (lhs != null) {
+    return lhs;
+  } else {
+    return rhsFn();
+  }
+}
+
+// From Sucrase
+export function _optionalChain(ops) {
+  let lastAccessLHS = undefined;
+  let value = ops[0];
+  let i = 1;
+  while (i < ops.length) {
+    const op = ops[i];
+    const fn = ops[i + 1];
+    i += 2;
+    if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {
+      return undefined;
+    }
+    if (op === 'access' || op === 'optionalAccess') {
+      lastAccessLHS = value;
+      value = fn(value);
+    } else if (op === 'call' || op === 'optionalCall') {
+      value = fn((...args) => value.call(lastAccessLHS, ...args));
+      lastAccessLHS = undefined;
+    }
+  }
+  return value;
+}
+
+// From Sucrase
+export function _optionalChainDelete(ops) {
+  const result = _optionalChain(ops);
+  // by checking for loose equality to `null`, we catch both `null` and `undefined`
+  return result == null ? true : result;
+}

rollup/jsPolyfills/_interopRequireDefault.js renamed to packages/dev-utils/src/jsPolyfills/_interopRequireDefault.js

@@ -5,5 +5,6 @@
 
   "compilerOptions": {
     // package-specific options
+    "types": ["node"]
   }
 }

rollup/jsPolyfills/_interopRequireWildcard.js renamed to packages/dev-utils/src/jsPolyfills/_interopRequireWildcard.js

@@ -8,5 +8,7 @@
     "types": ["node", "jest"],
 
     // other package-specific, test-specific options
+    // this is necessary in order to be able to handle the jsPolyfills `originals.js` which is used for testing
+    "allowJs": true
   }
 }

packages/dev-utils/src/jsPolyfills/_nullishCoalesce.ts

@@ -21,9 +21,6 @@
     "localforage": "^1.8.1",
     "tslib": "^1.9.3"
   },
-  "devDependencies": {
-    "chai": "^4.1.2"
-  },
   "scripts": {
     "build": "run-p build:cjs build:esm build:types build:bundle",
     "build:bundle": "bash scripts/buildBundles.sh",

rollup/jsPolyfills/_optionalChain.js renamed to packages/dev-utils/src/jsPolyfills/_optionalChain.ts

@@ -20,5 +20,5 @@
 ## General
 
 Common utilities used by the Sentry JavaScript SDKs. **Warning, only submodule imports are allowed here.** Also note,
-this function shouldn't be used externally, we will break them from time to time. This package is not part of our public
-API contract, we use them only internally.
+these functions shouldn't be used externally, as we may break them from time to time. This package is only meant to be used internally, and as such is not part of our public
+API contract and does not follow semver.

rollup/jsPolyfills/_optionalChainDelete.js renamed to packages/dev-utils/src/jsPolyfills/_optionalChainDelete.js

@@ -16,19 +16,19 @@
     "access": "public"
   },
   "dependencies": {
+    "@sentry-internal/dev-utils": "7.0.0-beta.0",
     "@sentry/types": "7.0.0-beta.0",
     "tslib": "^1.9.3"
   },
-  "devDependencies": {
-    "chai": "^4.1.2"
-  },
   "scripts": {
     "build": "run-p build:cjs build:esm build:types",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:dev": "run-s build",
     "build:es5": "yarn build:cjs # *** backwards compatibility - remove in v7 ***",
     "build:esm": "tsc -p tsconfig.esm.json",
-    "build:rollup": "rollup -c rollup.npm.config.js && rollup -c rollup.polyfills.config.js && cp ../../rollup/jsPolyfills/README.md jsPolyfills",
+    "build:rollup": "yarn rollup -c rollup.npm.config.js && cp ../dev-utils/src/jsPolyfills/README.md build/jsPolyfills && cp -r build/jsPolyfills . && echo \"**Dummy copy of polyfills (copied from \\`build/jsPolyfills\\`) necessary for tests.**\" > jsPolyfills/why-is-this-here?.md",
+    "build:rollup:code": "rollup -c rollup.npm.config.js",
+    "build:rollup:polyfills": "yarn rollup -c rollup.polyfills.config.js && cp ../../rollup/jsPolyfills/README.md jsPolyfills && yarn tsc --allowJs --skipLibCheck --declaration --emitDeclarationOnly ../../rollup/jsPolyfills/index.js && yarn tsc --allowJs --skipLibCheck --declaration --emitDeclarationOnly ../../rollup/jsPolyfills/originals.js",
     "build:types": "tsc -p tsconfig.types.json",
     "build:watch": "run-p build:cjs:watch build:esm:watch build:types:watch",
     "build:cjs:watch": "tsc -p tsconfig.cjs.json --watch",

packages/dev-utils/src/jsPolyfills/index.ts

@@ -1,3 +1,15 @@
+import * as path from 'path';
+
 import { makeBaseNPMConfig, makeNPMConfigVariants } from '../../rollup/index.js';
 
-export default makeNPMConfigVariants(makeBaseNPMConfig());
+const jsPolyfillsBaseConfig = makeBaseNPMConfig({ entrypoints: ['src/jsPolyfills.ts'] });
+
+jsPolyfillsBaseConfig.output.dir = path.join(jsPolyfillsBaseConfig.output.dir, 'jsPolyfills');
+jsPolyfillsBaseConfig.output.entryFileNames = 'index.js';
+
+export default [
+  // the standard, import-it-straight-from-the-package-like-normal code
+  ...makeNPMConfigVariants(makeBaseNPMConfig()),
+  // our tslib-like language and CJS/ESM interop helpers, which get imported from `@sentry/utils/jsPolyfills`
+  ...makeNPMConfigVariants(jsPolyfillsBaseConfig),
+];

packages/dev-utils/src/jsPolyfills/types.ts

@@ -0,0 +1,3 @@
+import { jsPolyfills } from '@sentry-internal/dev-utils';
+
+module.exports = jsPolyfills;