add workerbox etc

Author: silesky

packages/signals/signals-runtime/package.json

@@ -25,7 +25,6 @@
     "build:esm": "yarn tsc -p tsconfig.build.json",
     "build:cjs": "yarn tsc -p tsconfig.build.json --outDir ./dist/cjs --module commonjs",
     "build:global": "node build-signals-runtime-global.js",
-    "assert-generated": "bash scripts/assert-generated.sh",
     "watch": "rm -rf dist/esm && yarn build:esm && yarn build:esm --watch",
     "watch:test": "yarn test --watch",
     "tsc": "yarn run -T tsc",

packages/signals/signals-runtime/scripts/assert-generated.sh

@@ -1,5 +1,3 @@
-module.exports = {
-  ...require("@internal/config").lintStagedConfig,
-  'src/lib/workerbox/*.{js,ts,html}': ['yarn workerbox']
-}
+module.exports = require("@internal/config").lintStagedConfig,
+
 

packages/signals/signals/.lintstagedrc.js

@@ -32,8 +32,6 @@
     "build:esm": "yarn tsc -p tsconfig.build.json",
     "build:cjs": "yarn tsc -p tsconfig.build.json --outDir ./dist/cjs --module commonjs",
     "build:bundle": "NODE_ENV=production yarn run webpack",
-    "workerbox": "node scripts/build-workerbox.js",
-    "assert-generated": "sh scripts/assert-workerbox-built.sh",
     "watch": "rm -rf dist && yarn concurrently 'yarn build:bundle --watch' 'yarn build:esm --watch'",
     "version": "sh scripts/version.sh",
     "watch:test": "yarn test --watch",

packages/signals/signals/package.json

@@ -35,7 +35,10 @@ export class SignalsEventProcessorSubscriber implements SignalsSubscriber {
       sandboxSettings.processSignal
     ) {
       logger.debug('Initializing sandbox: iframe')
-      sandbox = new IframeSandbox(normalizedEdgeFunctionURL)
+      sandbox = new IframeSandbox(
+        normalizedEdgeFunctionURL,
+        sandboxSettings.processSignal
+      )
     } else {
       logger.debug('Initializing sandbox: global scope')
       sandbox = new GlobalScopeSandbox({

packages/signals/signals/scripts/assert-workerbox-built.sh

@@ -1,5 +1,4 @@
 import { logger } from '../../lib/logger'
-import { createWorkerBox, WorkerBoxAPI } from '../../lib/workerbox'
 import { resolvers } from './arg-resolvers'
 import { AnalyticsRuntimePublicApi, ProcessSignal } from '../../types'
 import { replaceBaseUrl } from '../../lib/replace-base-url'
@@ -129,33 +128,6 @@ class AnalyticsRuntime implements AnalyticsRuntimePublicApi {
   }
 }
 
-interface CodeSandbox {
-  run: (fn: string, scope: Record<string, any>) => Promise<any>
-  destroy: () => Promise<void>
-}
-
-class JavascriptSandbox implements CodeSandbox {
-  private workerbox: Promise<WorkerBoxAPI>
-  constructor() {
-    this.workerbox = createWorkerBox()
-  }
-  async run(fn: string, scope: Record<string, any>) {
-    try {
-      const wb = await this.workerbox
-      await wb.run(fn, scope)
-    } catch (err) {
-      console.error('processSignal() error in sandbox', err, {
-        fn,
-      })
-    }
-  }
-
-  async destroy(): Promise<void> {
-    const wb = await this.workerbox
-    await wb.destroy()
-  }
-}
-
 export const normalizeEdgeFunctionURL = (
   functionHost: string | undefined,
   edgeFnDownloadURL: string | undefined
@@ -185,39 +157,6 @@ const PROCESS_SIGNAL_UNDEFINED =
 
 const consoleWarnProcessSignal = () => console.warn(PROCESS_SIGNAL_UNDEFINED)
 
-export class IframeWorkerSandboxSettings {
-  /**
-   * Should look like:
-   * ```js
-   * function processSignal(signal) {
-   * ...
-   * }
-   * ```
-   */
-  processSignal: Promise<string>
-  constructor(settings: IframeSandboxSettingsConfig) {
-    const fetch = settings.edgeFnFetchClient ?? globalThis.fetch
-
-    let processSignalNormalized = Promise.resolve(
-      `globalThis.processSignal = function() {}`
-    )
-
-    if (settings.processSignal) {
-      processSignalNormalized = Promise.resolve(settings.processSignal).then(
-        (str) => `globalThis.processSignal = ${str}`
-      )
-    } else if (settings.edgeFnDownloadURL) {
-      processSignalNormalized = fetch(settings.edgeFnDownloadURL!).then((res) =>
-        res.text()
-      )
-    } else {
-      consoleWarnProcessSignal()
-    }
-
-    this.processSignal = processSignalNormalized
-  }
-}
-
 export interface SignalSandbox {
   execute(
     signal: Signal,
@@ -226,43 +165,6 @@ export interface SignalSandbox {
   destroy(): void | Promise<void>
 }
 
-export class WorkerSandbox implements SignalSandbox {
-  settings: IframeWorkerSandboxSettings
-  jsSandbox: CodeSandbox
-
-  constructor(settings: IframeWorkerSandboxSettings) {
-    this.settings = settings
-    this.jsSandbox = new JavascriptSandbox()
-  }
-
-  async execute(
-    signal: Signal,
-    signals: Signal[]
-  ): Promise<AnalyticsMethodCalls> {
-    const analytics = new AnalyticsRuntime()
-    const scope = {
-      analytics,
-    }
-    logger.debug('processing signal', { signal, scope, signals })
-    const code = [
-      polyfills,
-      await this.settings.processSignal,
-      getRuntimeCode(),
-      `signals.signalBuffer = ${JSON.stringify(signals)};`,
-      'try { processSignal(' +
-        JSON.stringify(signal) +
-        ', { analytics, signals, SignalType, EventType, NavigationAction }); } catch(err) { console.error("Process signal failed.", err); }',
-    ].join('\n')
-    await this.jsSandbox.run(code, scope)
-
-    const calls = analytics.getCalls()
-    return calls
-  }
-  destroy(): void {
-    void this.jsSandbox.destroy()
-  }
-}
-
 // ProcessSignal unfortunately uses globals. This should change.
 // For now, we are setting up the globals between each invocation
 const processWithGlobalScopeExecutionEnv = (
@@ -373,13 +275,14 @@ const noramizeMethodCallsWithArgResolver = (
   })
   return normalizedRuntime.getCalls()
 }
+
 export class IframeSandbox implements SignalSandbox {
   private iframe: HTMLIFrameElement
   private iframeReady: Promise<void>
   private _resolveReady!: () => void
   edgeFnUrl: string
 
-  constructor(edgeFnUrl: string) {
+  constructor(edgeFnUrl: string, processSignalFn?: string) {
     this.edgeFnUrl = edgeFnUrl
     this.iframe = document.createElement('iframe')
     this.iframe.id = 'segment-signals-sandbox'
@@ -405,16 +308,32 @@ export class IframeSandbox implements SignalSandbox {
     const doc = this.iframe.contentDocument!
     doc.open()
     doc.write(
-      `<!DOCTYPE html><html><head><script id="edge-fn" src=${this.edgeFnUrl}></script></head><body></body></html>`
+      [
+        `<!DOCTYPE html>`,
+        `<html>`,
+        `<head>`,
+        processSignalFn
+          ? ''
+          : `<script id="edge-fn" src=${this.edgeFnUrl}></script>`,
+        `</head>`,
+        `<body></body>
+      </html>`,
+      ].join(',')
     )
     doc.close()
 
     // External signal processor script
     // Inject runtime via Blob (CSP-safe)
     const runtimeJs = `
+    ${processSignalFn ? `window.processSignal = ${processSignalFn}` : ''}
+
      const signalsScript = document.getElementById('edge-fn')
-     signalsScript.onload = () => {
-       window.parent.postMessage('iframe_ready', '*')
+     if (typeof processSignal === 'undefined') {
+      signalsScript.onload = () => {
+        window.parent.postMessage('iframe_ready', '*')
+       }
+      } else {
+        window.parent.postMessage('iframe_ready', '*')
       }
  
       class AnalyticsRuntimeProxy {