@dxos/esbuild-plugins 0.1.14

package/polyfills/crypto.js

@@ -0,0 +1,7 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+export * from 'crypto-browserify';
+// eslint-disable-next-line no-undef
+export const webcrypto = self.crypto;

package/polyfills/empty-module-stub.js

@@ -0,0 +1,4 @@
+/* eslint-disable */
+
+// Stub for an empty module.
+module.exports = {};

package/polyfills/module.js

@@ -0,0 +1,5 @@
+/* eslint-disable */
+
+module.exports = {
+  builtinModules: [],
+}

package/polyfills/process.js

@@ -0,0 +1,261 @@
+// shim for using process in browser
+// based off https://github.com/defunctzombie/node-process/blob/master/browser.js
+/* eslint-disable */
+
+var _window = this || self || window;
+_window.global = _window;
+
+function defaultSetTimout () {
+  throw new Error('setTimeout has not been defined');
+}
+
+function defaultClearTimeout () {
+  throw new Error('clearTimeout has not been defined');
+}
+
+var cachedSetTimeout = defaultSetTimout;
+var cachedClearTimeout = defaultClearTimeout;
+if (typeof global.setTimeout === 'function') {
+  cachedSetTimeout = setTimeout;
+}
+if (typeof global.clearTimeout === 'function') {
+  cachedClearTimeout = clearTimeout;
+}
+
+function runTimeout (fun) {
+  if (cachedSetTimeout === setTimeout) {
+    //normal enviroments in sane situations
+    return setTimeout(fun, 0);
+  }
+  // if setTimeout wasn't available but was latter defined
+  if (
+    (cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) &&
+    setTimeout
+  ) {
+    cachedSetTimeout = setTimeout;
+    return setTimeout(fun, 0);
+  }
+  try {
+    // when when somebody has screwed with setTimeout but no I.E. maddness
+    return cachedSetTimeout(fun, 0);
+  } catch (e) {
+    try {
+      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+      return cachedSetTimeout.call(null, fun, 0);
+    } catch (e) {
+      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+      return cachedSetTimeout.call(this, fun, 0);
+    }
+  }
+}
+
+function runClearTimeout (marker) {
+  if (cachedClearTimeout === clearTimeout) {
+    //normal enviroments in sane situations
+    return clearTimeout(marker);
+  }
+  // if clearTimeout wasn't available but was latter defined
+  if (
+    (cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) &&
+    clearTimeout
+  ) {
+    cachedClearTimeout = clearTimeout;
+    return clearTimeout(marker);
+  }
+  try {
+    // when when somebody has screwed with setTimeout but no I.E. maddness
+    return cachedClearTimeout(marker);
+  } catch (e) {
+    try {
+      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+      return cachedClearTimeout.call(null, marker);
+    } catch (e) {
+      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+      // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+      return cachedClearTimeout.call(this, marker);
+    }
+  }
+}
+
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick () {
+  if (!draining || !currentQueue) {
+    return;
+  }
+  draining = false;
+  if (currentQueue.length) {
+    queue = currentQueue.concat(queue);
+  } else {
+    queueIndex = -1;
+  }
+  if (queue.length) {
+    drainQueue();
+  }
+}
+
+function drainQueue () {
+  if (draining) {
+    return;
+  }
+  var timeout = runTimeout(cleanUpNextTick);
+  draining = true;
+
+  var len = queue.length;
+  while (len) {
+    currentQueue = queue;
+    queue = [];
+    while (++queueIndex < len) {
+      if (currentQueue) {
+        currentQueue[queueIndex].run();
+      }
+    }
+    queueIndex = -1;
+    len = queue.length;
+  }
+  currentQueue = null;
+  draining = false;
+  runClearTimeout(timeout);
+}
+
+function nextTick (fun) {
+  var args = new Array(arguments.length - 1);
+  if (arguments.length > 1) {
+    for (var i = 1; i < arguments.length; i++) {
+      args[i - 1] = arguments[i];
+    }
+  }
+  queue.push(new Item(fun, args));
+  if (queue.length === 1 && !draining) {
+    runTimeout(drainQueue);
+  }
+}
+
+// v8 likes predictible objects
+function Item (fun, array) {
+  this.fun = fun;
+  this.array = array;
+}
+
+Item.prototype.run = function () {
+  this.fun.apply(null, this.array);
+};
+var title = 'browser';
+var platform = 'browser';
+var browser = true;
+var env = {};
+var argv = [];
+var version = ''; // empty string to avoid regexp issues
+var versions = {};
+var release = {};
+var config = {};
+
+function noop () {}
+
+var on = noop;
+var addListener = noop;
+var once = noop;
+var off = noop;
+var removeListener = noop;
+var removeAllListeners = noop;
+var emit = noop;
+
+function binding (name) {
+  throw new Error('process.binding is not supported');
+}
+
+function cwd () {
+  return '/';
+}
+
+function chdir (dir) {
+  throw new Error('process.chdir is not supported');
+}
+
+function umask () {
+  return 0;
+}
+
+// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js
+var performance = global.performance || {};
+var performanceNow =
+  performance.now ||
+  performance.mozNow ||
+  performance.msNow ||
+  performance.oNow ||
+  performance.webkitNow ||
+  function () {
+    return new Date().getTime();
+  };
+
+// generate timestamp or delta
+// see http://nodejs.org/api/process.html#process_process_hrtime
+function hrtime (previousTimestamp) {
+  var clocktime = performanceNow.call(performance) * 1e-3;
+  var seconds = Math.floor(clocktime);
+  var nanoseconds = Math.floor((clocktime % 1) * 1e9);
+  if (previousTimestamp) {
+    seconds = seconds - previousTimestamp[0];
+    nanoseconds = nanoseconds - previousTimestamp[1];
+    if (nanoseconds < 0) {
+      seconds--;
+      nanoseconds += 1e9;
+    }
+  }
+  return [seconds, nanoseconds];
+}
+
+var startTime = new Date();
+
+function uptime () {
+  var currentTime = new Date();
+  var dif = currentTime - startTime;
+  return dif / 1000;
+}
+
+_window.setImmediate = nextTick;
+
+export var process = {
+  nextTick: nextTick,
+  title: title,
+  browser: browser,
+  env: env,
+  argv: argv,
+  version: version,
+  versions: versions,
+  on: on,
+  addListener: addListener,
+  once: once,
+  off: off,
+  removeListener: removeListener,
+  removeAllListeners: removeAllListeners,
+  emit: emit,
+  binding: binding,
+  cwd: cwd,
+  chdir: chdir,
+  umask: umask,
+  hrtime: hrtime,
+  platform: platform,
+  release: release,
+  config: config,
+  uptime: uptime,
+};
+
+// replace process.env.VAR with define
+
+const defines = {};
+Object.keys(defines).forEach((key) => {
+  const segs = key.split('.');
+  let target = process;
+  for (let i = 0; i < segs.length; i++) {
+    const seg = segs[i];
+    if (i === segs.length - 1) {
+      target[seg] = defines[key];
+    } else {
+      target = target[seg] || (target[seg] = {});
+    }
+  }
+});

package/project.json

@@ -0,0 +1,32 @@
+{
+  "sourceRoot": "packages/common/esbuild-plugins/src",
+  "projectType": "library",
+  "targets": {
+    "compile": {
+      "executor": "@nrwl/js:tsc",
+      "options": {
+        "main": "packages/common/esbuild-plugins/src/index.ts",
+        "outputPath": "packages/common/esbuild-plugins/dist",
+        "transformers": [
+          "@dxos/log-hook/transformer"
+        ],
+        "tsConfig": "packages/common/esbuild-plugins/tsconfig.json"
+      },
+      "outputs": [
+        "{options.outputPath}"
+      ]
+    },
+    "lint": {
+      "executor": "@nrwl/linter:eslint",
+      "options": {
+        "format": "unix",
+        "lintFilePatterns": [
+          "packages/common/esbuild-plugins/**/*.{ts,js}"
+        ]
+      },
+      "outputs": [
+        "{options.outputFile}"
+      ]
+    }
+  }
+}

package/src/fix-graceful-fs-plugin.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import type { Plugin } from 'esbuild';
+
+/**
+ * Replace graceful-fs with an empty module when bundling for browser.
+ */
+export const FixGracefulFsPlugin = (): Plugin => ({
+  name: 'fix-graceful-fs-plugin',
+  setup: ({ onResolve, onLoad }) => {
+    onResolve({ filter: /^graceful-fs$/ }, (arg) => {
+      return {
+        path: 'graceful-fs',
+        namespace: 'fix-graceful-fs-plugin'
+      };
+    });
+
+    onLoad({ filter: /^graceful-fs$/, namespace: 'fix-graceful-fs-plugin' }, async (args) => {
+      return {
+        contents: 'module.exports = {};',
+        loader: 'js'
+      };
+    });
+  }
+});

package/src/fix-memdown-plugin.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import type { Plugin } from 'esbuild';
+
+/**
+ * Some odd path resolution in memdown package.
+ */
+export const FixMemdownPlugin = (): Plugin => ({
+  name: 'fix-memdown-plugin',
+  setup: ({ onResolve }) => {
+    onResolve({ filter: /^immediate$/ }, (arg) => {
+      return {
+        path: require.resolve(arg.path, { paths: [arg.resolveDir] })
+      };
+    });
+  }
+});

package/src/index.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+export * from './fix-graceful-fs-plugin';
+export * from './fix-memdown-plugin';
+export * from './node-globals-polyfill-plugin';
+export * from './node-modules-plugin';

package/src/node-globals-polyfill-plugin.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import type { Plugin } from 'esbuild';
+import { resolve } from 'path';
+
+/**
+ * Injects node globals such as `Buffer` or `process`.
+ */
+export const NodeGlobalsPolyfillPlugin = (): Plugin => ({
+  name: 'node-globals-polyfill',
+  setup: ({ initialOptions }) => {
+    const polyfills = [
+      // TODO: Use `buffer` module from NPM.
+      resolve(__dirname, '../../polyfills/process.js'),
+      resolve(__dirname, '../../polyfills/Buffer.js')
+    ];
+    if (initialOptions.inject) {
+      initialOptions.inject.push(...polyfills);
+    } else {
+      initialOptions.inject = [...polyfills];
+    }
+  }
+});

package/src/node-modules-plugin.ts

@@ -0,0 +1,84 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import type { Plugin } from 'esbuild';
+
+/**
+ * Adds polyfills for node's built-in modules.
+ */
+export const NodeModulesPlugin = (): Plugin => ({
+  name: 'node-modules-plugin',
+  setup: ({ onResolve }) => {
+    onResolve({ filter: /^(node:)?assert$/ }, (arg) => {
+      return {
+        path: require.resolve('assert/') // Appending slash makes node resolve the installed package from node_modules.
+      };
+    });
+    onResolve({ filter: /^(node:)?buffer$/ }, (arg) => {
+      return {
+        path: require.resolve('../../polyfills/Buffer.js')
+      };
+    });
+    onResolve({ filter: /^(node:)?domain$/ }, (arg) => {
+      return {
+        path: require.resolve('domain-browser')
+      };
+    });
+    onResolve({ filter: /^(node:)?stream$/ }, (arg) => {
+      return {
+        path: require.resolve('readable-stream')
+      };
+    });
+    onResolve({ filter: /^(node:)?path$/ }, (arg) => {
+      return {
+        path: require.resolve('path-browserify')
+      };
+    });
+    onResolve({ filter: /^(node:)?events$/ }, (arg) => {
+      return {
+        path: require.resolve('events/')
+      };
+    });
+    onResolve({ filter: /^(node:)?util$/ }, (arg) => {
+      return {
+        path: require.resolve('util/')
+      };
+    });
+    onResolve({ filter: /^(node:)?http$/ }, (arg) => {
+      return {
+        path: require.resolve('../../polyfills/empty-module-stub.js')
+      };
+    });
+    onResolve({ filter: /^(node:)?https$/ }, (arg) => {
+      return {
+        path: require.resolve('../../polyfills/empty-module-stub.js')
+      };
+    });
+    onResolve({ filter: /^(node:)?module$/ }, (arg) => {
+      return {
+        path: require.resolve('../../polyfills/module.js')
+      };
+    });
+    onResolve({ filter: /^(node:)?crypto$/ }, (arg) => {
+      return {
+        path: require.resolve('../../polyfills/crypto.js')
+      };
+    });
+    onResolve({ filter: /^(node:)?debug$/ }, (arg) => {
+      return {
+        path: require.resolve('debug') // Resolves to installed debug module.
+      };
+    });
+    onResolve({ filter: /^(node:)?tty$/ }, (arg) => {
+      return {
+        path: require.resolve('tty-browserify')
+      };
+    });
+    onResolve({ filter: /^(node:)?fs$/ }, (arg) => {
+      return {
+        path: require.resolve('../../polyfills/empty-module-stub.js')
+      };
+    });
+  }
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "emitDeclarationOnly": false,
+    "outDir": "dist",
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "src"
+  ],
+  "references": []
+}