rauschma/about.md

## about.md

      
    Raw
  

              about.md
            
          
    Transferring objects between a ShadowRealm and an incubator realm


Problem: We can only transfer callable objects and primitive values between a ShadowRealm and an incubator realm.
This code demonstrates a simple solution (that’s not completely safe).

Runs in Safari Technology Preview: https://webkit.org/blog/12522/release-notes-for-safari-technology-preview-142/


A more complete solution: https://github.com/caridy/irealm

Material:

Proposal for ShadowRealms: https://github.com/tc39/proposal-shadowrealm
Proxies: https://exploringjs.com/deep-js/ch_proxies.html


## index.html
<!doctype html>
<html>
<head>
  <meta charset="UTF-8">
  <title>Membrane</title>
</head>
<body>
  <script type="module">
    import {createShadowEval} from './membrane-lib.js';

    const sr = new ShadowRealm();
    const shadowEval = await createShadowEval(sr);

    const obj = shadowEval(`
      ({
        brand: 'Ford',
        owner: {
          first: 'Jane',
          last: 'Doe',
        },
      })
    `);

    console.log(obj.brand); // 'Ford'
    console.log(obj.owner.first); // 'Jane'
  </script>
</body>
</html>

## membrane-lib.js
function isObject(value) {
  return (
    (value !== null && typeof value === 'object')
    || typeof value === 'function'
  );
}

/**
 * We can’t transfer a (non-callable) object across realms.
 * But we can transfer a function that applies proxy-trapped operations
 * to the object.
 */
export function wrapLocalValue(value) {
  if (isObject(value)) {
    return (trapName, ...args) => {
      const wrappedArgs = args.map(arg => wrapForeignValue(arg));
      const result = Reflect[trapName](value, ...wrappedArgs);
      return wrapLocalValue(result);
    };
  } else {
    return value;
  }
}

/**
 * To use a wrapped object from another realm in the current realm,
 * we create a Proxy that feeds the operations it traps to the function.
 */
export function wrapForeignValue(value) {
  if (!isObject(value)) {
    return value;
  }

  // All handler methods follow the same pattern.
  // To avoid repetitive code, we create it via a loop.
  const handler = {};
  for (const trapName of Object.getOwnPropertyNames(Reflect)) {
    handler[trapName] = (_target, ...args) => {
      const wrappedArgs = args.map(arg => wrapLocalValue(arg));
      const result = value(trapName, ...wrappedArgs);
      return wrapForeignValue(result);
    };
  }

  const target = function () {};
  return new Proxy(target, handler);
}

export async function createShadowEval(shadowRealm) {
  const _getLocallyWrappedEval = await shadowRealm.importValue(import.meta.url, '_getLocallyWrappedEval');
  return wrapForeignValue(_getLocallyWrappedEval());
}

export async function createShadowImport(shadowRealm) {
  const _getLocallyWrappedImport = await shadowRealm.importValue(import.meta.url, '_getLocallyWrappedImport');
  return wrapForeignValue(_getLocallyWrappedImport());
}

export function _getLocallyWrappedEval() {
  return wrapLocalValue(globalThis.eval);
}

export function _getLocallyWrappedImport() {
  return wrapLocalValue((moduleSpecifier) => import(moduleSpecifier));
}
	<!doctype html>
	<html>
	<head>
	<meta charset="UTF-8">
	<title>Membrane</title>
	</head>
	<body>
	<script type="module">
	import {createShadowEval} from './membrane-lib.js';

	const sr = new ShadowRealm();
	const shadowEval = await createShadowEval(sr);

	const obj = shadowEval(`
	({
	brand: 'Ford',
	owner: {
	first: 'Jane',
	last: 'Doe',
	},
	})
	`);

	console.log(obj.brand); // 'Ford'
	console.log(obj.owner.first); // 'Jane'
	</script>
	</body>
	</html>
	function isObject(value) {
	return (
	(value !== null && typeof value === 'object')
	\|\| typeof value === 'function'
	);
	}

	/**
	* We can’t transfer a (non-callable) object across realms.
	* But we can transfer a function that applies proxy-trapped operations
	* to the object.
	*/
	export function wrapLocalValue(value) {
	if (isObject(value)) {
	return (trapName, ...args) => {
	const wrappedArgs = args.map(arg => wrapForeignValue(arg));
	const result = Reflect[trapName](value, ...wrappedArgs);
	return wrapLocalValue(result);
	};
	} else {
	return value;
	}
	}

	/**
	* To use a wrapped object from another realm in the current realm,
	* we create a Proxy that feeds the operations it traps to the function.
	*/
	export function wrapForeignValue(value) {
	if (!isObject(value)) {
	return value;
	}

	// All handler methods follow the same pattern.
	// To avoid repetitive code, we create it via a loop.
	const handler = {};
	for (const trapName of Object.getOwnPropertyNames(Reflect)) {
	handler[trapName] = (_target, ...args) => {
	const wrappedArgs = args.map(arg => wrapLocalValue(arg));
	const result = value(trapName, ...wrappedArgs);
	return wrapForeignValue(result);
	};
	}

	const target = function () {};
	return new Proxy(target, handler);
	}

	export async function createShadowEval(shadowRealm) {
	const _getLocallyWrappedEval = await shadowRealm.importValue(import.meta.url, '_getLocallyWrappedEval');
	return wrapForeignValue(_getLocallyWrappedEval());
	}

	export async function createShadowImport(shadowRealm) {
	const _getLocallyWrappedImport = await shadowRealm.importValue(import.meta.url, '_getLocallyWrappedImport');
	return wrapForeignValue(_getLocallyWrappedImport());
	}

	export function _getLocallyWrappedEval() {
	return wrapLocalValue(globalThis.eval);
	}

	export function _getLocallyWrappedImport() {
	return wrapLocalValue((moduleSpecifier) => import(moduleSpecifier));
	}