Bundle structuredClone implementation for GJS

Author: amezin

.prettierignore

@@ -0,0 +1 @@
+src/core/structuredClone.js

eslint.config.mjs

@@ -53,4 +53,14 @@ export default defineConfig([{
     "no-debugger": "error",
     "no-console": "error",
   },
+}], [{
+  files: ["scripts/lib/structuredClone.rollup.js"],
+  languageOptions: {
+    sourceType: "module",
+  }
+}], [{
+  files: ["src/core/structuredClone.js"],
+  rules: {
+    curly: "off",
+  }
 }]);

lib/jasmine-core/jasmine.js

@@ -53,6 +53,11 @@ const getJasmineRequireObj = (function() {
 
     jRequire.base(j$, private$, globalThis);
     private$.util = jRequire.util(j$, private$);
+    private$.structuredClone = jRequire.structuredClone(
+      j$,
+      private$,
+      globalThis
+    );
     private$.errors = jRequire.errors();
     private$.formatErrorMsg = jRequire.formatErrorMsg(j$, private$);
     private$.AllOf = jRequire.AllOf(j$, private$);
@@ -821,7 +826,7 @@ getJasmineRequireObj().util = function(j$, private$) {
       // Reporter events are cloned internally via structuredClone, and it's
       // common for reporters (including jasmine-browser-runner's) to JSON
       // serialize them.
-      JSON.stringify(structuredClone(v));
+      JSON.stringify(private$.structuredClone(v));
     } catch (e) {
       throw new Error(`${msgPrefix} can't be cloned`, { cause: e });
     }
@@ -8881,7 +8886,7 @@ getJasmineRequireObj().ReportDispatcher = function(j$, private$) {
         return;
       }
 
-      const thisEvent = structuredClone(event);
+      const thisEvent = private$.structuredClone(event);
       if (fn.length <= 1) {
         fns.push({
           fn: function() {
@@ -11025,6 +11030,292 @@ getJasmineRequireObj().StackTrace = function(j$, private$) {
   return StackTrace;
 };
 
+(function () {
+  'use strict';
+
+  const VOID       = -1;
+  const PRIMITIVE  = 0;
+  const ARRAY      = 1;
+  const OBJECT     = 2;
+  const DATE       = 3;
+  const REGEXP     = 4;
+  const MAP        = 5;
+  const SET        = 6;
+  const ERROR      = 7;
+  const BIGINT     = 8;
+  // export const SYMBOL = 9;
+
+  const env = typeof self === 'object' ? self : globalThis;
+
+  const guard = (name, init) => {
+    switch (name) {
+      case 'Function':
+      case 'SharedWorker':
+      case 'Worker':
+      case 'eval':
+      case 'setInterval':
+      case 'setTimeout':
+        throw new TypeError('unable to deserialize ' + name);
+    }
+    return new env[name](init);
+  };
+
+  const deserializer = ($, _) => {
+    const as = (out, index) => {
+      $.set(index, out);
+      return out;
+    };
+
+    const unpair = index => {
+      if ($.has(index))
+        return $.get(index);
+
+      const [type, value] = _[index];
+      switch (type) {
+        case PRIMITIVE:
+        case VOID:
+          return as(value, index);
+        case ARRAY: {
+          const arr = as([], index);
+          for (const index of value)
+            arr.push(unpair(index));
+          return arr;
+        }
+        case OBJECT: {
+          const object = as({}, index);
+          for (const [key, index] of value)
+            object[unpair(key)] = unpair(index);
+          return object;
+        }
+        case DATE:
+          return as(new Date(value), index);
+        case REGEXP: {
+          const {source, flags} = value;
+          return as(new RegExp(source, flags), index);
+        }
+        case MAP: {
+          const map = as(new Map, index);
+          for (const [key, index] of value)
+            map.set(unpair(key), unpair(index));
+          return map;
+        }
+        case SET: {
+          const set = as(new Set, index);
+          for (const index of value)
+            set.add(unpair(index));
+          return set;
+        }
+        case ERROR: {
+          const {name, message} = value;
+          return as(guard(name, message), index);
+        }
+        case BIGINT:
+          return as(BigInt(value), index);
+        case 'BigInt':
+          return as(Object(BigInt(value)), index);
+        case 'ArrayBuffer':
+          return as(new Uint8Array(value).buffer, value);
+        case 'DataView': {
+          const { buffer } = new Uint8Array(value);
+          return as(new DataView(buffer), value);
+        }
+      }
+      return as(guard(type, value), index);
+    };
+
+    return unpair;
+  };
+
+  /**
+   * @typedef {Array<string,any>} Record a type representation
+   */
+
+  /**
+   * Returns a deserialized value from a serialized array of Records.
+   * @param {Record[]} serialized a previously serialized value.
+   * @returns {any}
+   */
+  const deserialize = serialized => deserializer(new Map, serialized)(0);
+
+  const EMPTY = '';
+
+  const {toString} = {};
+  const {keys} = Object;
+
+  const typeOf = value => {
+    const type = typeof value;
+    if (type !== 'object' || !value)
+      return [PRIMITIVE, type];
+
+    const asString = toString.call(value).slice(8, -1);
+    switch (asString) {
+      case 'Array':
+        return [ARRAY, EMPTY];
+      case 'Object':
+        return [OBJECT, EMPTY];
+      case 'Date':
+        return [DATE, EMPTY];
+      case 'RegExp':
+        return [REGEXP, EMPTY];
+      case 'Map':
+        return [MAP, EMPTY];
+      case 'Set':
+        return [SET, EMPTY];
+      case 'DataView':
+        return [ARRAY, asString];
+    }
+
+    if (asString.includes('Array'))
+      return [ARRAY, asString];
+
+    if (asString.includes('Error'))
+      return [ERROR, asString];
+
+    return [OBJECT, asString];
+  };
+
+  const shouldSkip = ([TYPE, type]) => (
+    TYPE === PRIMITIVE &&
+    (type === 'function' || type === 'symbol')
+  );
+
+  const serializer = (strict, json, $, _) => {
+
+    const as = (out, value) => {
+      const index = _.push(out) - 1;
+      $.set(value, index);
+      return index;
+    };
+
+    const pair = value => {
+      if ($.has(value))
+        return $.get(value);
+
+      let [TYPE, type] = typeOf(value);
+      switch (TYPE) {
+        case PRIMITIVE: {
+          let entry = value;
+          switch (type) {
+            case 'bigint':
+              TYPE = BIGINT;
+              entry = value.toString();
+              break;
+            case 'function':
+            case 'symbol':
+              if (strict)
+                throw new TypeError('unable to serialize ' + type);
+              entry = null;
+              break;
+            case 'undefined':
+              return as([VOID], value);
+          }
+          return as([TYPE, entry], value);
+        }
+        case ARRAY: {
+          if (type) {
+            let spread = value;
+            if (type === 'DataView') {
+              spread = new Uint8Array(value.buffer);
+            }
+            else if (type === 'ArrayBuffer') {
+              spread = new Uint8Array(value);
+            }
+            return as([type, [...spread]], value);
+          }
+
+          const arr = [];
+          const index = as([TYPE, arr], value);
+          for (const entry of value)
+            arr.push(pair(entry));
+          return index;
+        }
+        case OBJECT: {
+          if (type) {
+            switch (type) {
+              case 'BigInt':
+                return as([type, value.toString()], value);
+              case 'Boolean':
+              case 'Number':
+              case 'String':
+                return as([type, value.valueOf()], value);
+            }
+          }
+
+          if (json && ('toJSON' in value))
+            return pair(value.toJSON());
+
+          const entries = [];
+          const index = as([TYPE, entries], value);
+          for (const key of keys(value)) {
+            if (strict || !shouldSkip(typeOf(value[key])))
+              entries.push([pair(key), pair(value[key])]);
+          }
+          return index;
+        }
+        case DATE:
+          return as([TYPE, value.toISOString()], value);
+        case REGEXP: {
+          const {source, flags} = value;
+          return as([TYPE, {source, flags}], value);
+        }
+        case MAP: {
+          const entries = [];
+          const index = as([TYPE, entries], value);
+          for (const [key, entry] of value) {
+            if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))
+              entries.push([pair(key), pair(entry)]);
+          }
+          return index;
+        }
+        case SET: {
+          const entries = [];
+          const index = as([TYPE, entries], value);
+          for (const entry of value) {
+            if (strict || !shouldSkip(typeOf(entry)))
+              entries.push(pair(entry));
+          }
+          return index;
+        }
+      }
+
+      const {message} = value;
+      return as([TYPE, {name: type, message}], value);
+    };
+
+    return pair;
+  };
+
+  /**
+   * @typedef {Array<string,any>} Record a type representation
+   */
+
+  /**
+   * Returns an array of serialized Records.
+   * @param {any} value a serializable value.
+   * @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that,
+   *  if `true`, will not throw errors on incompatible types, and behave more
+   *  like JSON stringify would behave. Symbol and Function will be discarded.
+   * @returns {Record[]}
+   */
+   const serialize = (value, {json, lossy} = {}) => {
+    const _ = [];
+    return serializer(!(json || lossy), !!json, new Map, _)(value), _;
+  };
+
+  getJasmineRequireObj().structuredClone = function(j$, private$, jasmineGlobal) {
+    const { structuredClone } = jasmineGlobal;
+
+    if (structuredClone) {
+      return structuredClone.bind(jasmineGlobal);
+    }
+
+    return function (any, options) {
+      return deserialize(serialize(any, options));
+    };
+  };
+
+})();
+
 getJasmineRequireObj().Suite = function(j$, private$) {
   'use strict';