refactor(compartment-mapper): refactor bundler to produce less output

Co-authored-by: naugtur <[email protected]>
Co-authered-by: kumavis <[email protected]>

Author: kumavis

packages/compartment-mapper/scripts/bundle-live-test.js

@@ -14,6 +14,13 @@ const readPowers = makeReadPowers({ fs, url });
 
 const bundle = await makeBundle(readPowers.read, fixture);
 fs.writeFileSync(url.fileURLToPath(target), bundle);
+// fs.writeFileSync(url.fileURLToPath(`${target}.${Date.now()}`), bundle);
 
+console.log(`
+#######################
+size: ${bundle.length}
+`);
+
+// eslint-disable-next-line no-undef
 global.print = console.log;
 import(target);

packages/compartment-mapper/src/bundle-cjs.js

@@ -1,18 +1,7 @@
-/** quotes strings */
-const q = JSON.stringify;
-
-const exportsCellRecord = exportsList =>
-  ''.concat(
-    ...exportsList.map(
-      exportName => `\
-      ${exportName}: cell(${q(exportName)}),
-`,
-    ),
-  );
-
+// vvv runtime to inline in the bundle vvv
+/* eslint-disable no-undef */
 // This function is serialized and references variables from its destination scope.
-const runtime = function wrapCjsFunctor(num) {
-  /* eslint-disable no-undef */
+function wrapCjsFunctor(num) {
   return ({ imports = {} }) => {
     const cModule = Object.freeze(
       Object.defineProperty({}, 'exports', cells[num].default),
@@ -24,8 +13,11 @@ const runtime = function wrapCjsFunctor(num) {
       .filter(k => k !== 'default' && k !== '*')
       .map(k => cells[num][k].set(cModule.exports[k]));
   };
-  /* eslint-enable no-undef */
-}.toString();
+}
+/* eslint-enable no-undef */
+const runtime = `\
+${wrapCjsFunctor}`;
+// ^^^ runtime to inline in the bundle ^^^
 
 export default {
   runtime,
@@ -41,11 +33,7 @@ export default {
 // === functors[${index}] ===
 ${cjsFunctor},
 `,
-      getCells: () => `\
-    {
-${exportsCellRecord(exportsList)}\
-    },
-`,
+      getCells: () => exportsList,
       getReexportsWiring: () => '',
       getFunctorCall: () => `\
   wrapCjsFunctor(${index})({imports: ${importsMap}});

packages/compartment-mapper/src/bundle-json.js

@@ -6,9 +6,7 @@ export default {
 // === functors[${index}] ===
 ${sourceText},
 `,
-      getCells: () => `\
-    { default: cell('default') }, 
-`,
+      getCells: () => ['default'],
       getReexportsWiring: () => '',
       getFunctorCall: () => `\
   cells[${index}].default.set(functors[${index}]);

packages/compartment-mapper/src/bundle-mjs.js

@@ -1,15 +1,6 @@
 /** quotes strings */
 const q = JSON.stringify;
 
-const exportsCellRecord = exportMap =>
-  ''.concat(
-    ...Object.keys(exportMap).map(
-      exportName => `\
-      ${exportName}: cell(${q(exportName)}),
-`,
-    ),
-  );
-
 const importsCellSetter = (exportMap, index) =>
   ''.concat(
     ...Object.entries(exportMap).map(
@@ -19,31 +10,56 @@ const importsCellSetter = (exportMap, index) =>
     ),
   );
 
-const adaptReexport = reexportMap => {
+const importImplementation = indexedImports => {
+  const knownEntries = Object.entries(indexedImports);
+  if (knownEntries.length === 0) {
+    return `imports() {},`;
+  }
+  return `\
+imports(entries) {
+      const map = new Map(entries);
+      observeImports(map, [
+  ${''.concat(
+    ...knownEntries.map(
+      ([importName, importIndex]) => `\
+    [${q(importName)}, ${importIndex}],
+  `,
+    ),
+  )}\
+    ]);},`;
+};
+
+const getReexportKeys = reexportMap => {
   if (!reexportMap) {
     return {};
   }
-  const ret = Object.fromEntries(
-    Object.values(reexportMap)
-      .flat()
-      .map(([local, exported]) => [exported, [local]]),
-  );
-  return ret;
+  return Object.values(reexportMap)
+    .flat()
+    .map(([local, _exported]) => local);
 };
 
-export const runtime = `\
-function observeImports(map, importName, importIndex) {
-  for (const [name, observers] of map.get(importName)) {
-    const cell = cells[importIndex][name];
-    if (cell === undefined) {
-      throw new ReferenceError(\`Cannot import name \${name}\`);
-    }
-    for (const observer of observers) {
-      cell.observe(observer);
+// vvv runtime to inline in the bundle vvv
+/* eslint-disable no-undef */
+function observeImports(map, pairs) {
+  for (const [importName, importIndex] of pairs) {
+    for (const [name, observers] of map.get(importName)) {
+      const cell = cells[importIndex][name];
+      if (cell === undefined) {
+        throw new ReferenceError(`Cannot import name ${name}`);
+      }
+      for (const observer of observers) {
+        cell.observe(observer);
+      }
     }
   }
 }
-`;
+
+/* eslint-enable no-undef */
+
+const runtime = `\
+${observeImports}
+${observeImports}`;
+// ^^^ runtime to inline in the bundle ^^^
 
 export default {
   runtime,
@@ -55,6 +71,7 @@ export default {
       __fixedExportMap__ = {},
       __liveExportMap__ = {},
       __reexportMap__ = {},
+      __needsImportMeta__ = false,
       reexports,
     },
   }) {
@@ -63,19 +80,17 @@ export default {
 // === functors[${index}] ===
 ${__syncModuleProgram__},
 `,
-      getCells: () => `\
-    {
-${exportsCellRecord(__fixedExportMap__)}${exportsCellRecord(
-        __liveExportMap__,
-      )}${exportsCellRecord(adaptReexport(__reexportMap__))}\
-    },
-`,
+      getCells: () => [
+        ...Object.keys(__fixedExportMap__),
+        ...Object.keys(__liveExportMap__),
+        ...getReexportKeys(__reexportMap__),
+      ],
+      reexportedCells: reexports.map(importSpecifier => [
+        index,
+        indexedImports[importSpecifier],
+      ]),
       getReexportsWiring: () => {
-        const mappings = reexports.map(
-          importSpecifier => `\
-  Object.defineProperties(cells[${index}], Object.getOwnPropertyDescriptors(cells[${indexedImports[importSpecifier]}]));
-`,
-        );
+        const mappings = [];
         // Create references for export name as newname
         const namedReexportsToProcess = Object.entries(__reexportMap__);
         if (namedReexportsToProcess.length > 0) {
@@ -96,23 +111,14 @@ ${exportsCellRecord(__fixedExportMap__)}${exportsCellRecord(
       },
       getFunctorCall: () => `\
   functors[${index}]({
-    imports(entries) {
-      const map = new Map(entries);
-  ${''.concat(
-    ...Object.entries(indexedImports).map(
-      ([importName, importIndex]) => `\
-    observeImports(map, ${q(importName)}, ${importIndex});
-  `,
-    ),
-  )}\
-  },
+    ${importImplementation(indexedImports)}
     liveVar: {
   ${importsCellSetter(__liveExportMap__, index)}\
   },
     onceVar: {
 ${importsCellSetter(__fixedExportMap__, index)}\
-    },
-    importMeta: {},
+    },\
+${__needsImportMeta__ ? '\n    importMeta: {},' : ''}
   });
 `,
     };

packages/compartment-mapper/src/bundle.js

@@ -149,6 +149,49 @@ function getBundlerKitForModule(module) {
   return getBundlerKit(module);
 }
 
+// vvv runtime to inline in the bundle vvv
+/* eslint-disable no-undef */
+function cell(name, value = undefined) {
+  const observers = [];
+  return Object.freeze({
+    get: Object.freeze(() => {
+      return value;
+    }),
+    set: Object.freeze(newValue => {
+      value = newValue;
+      for (const observe of observers) {
+        observe(value);
+      }
+    }),
+    observe: Object.freeze(observe => {
+      observers.push(observe);
+      observe(value);
+    }),
+    enumerable: true,
+  });
+}
+function makeCells(orderedCells, reexports) {
+  const cells = orderedCells.map(cs =>
+    cs.reduce((kv, c) => {
+      kv[c] = cell(c);
+      return kv;
+    }, {}),
+  );
+  for (const [to, from] of reexports) {
+    Object.defineProperties(
+      cells[to],
+      Object.getOwnPropertyDescriptors(cells[from]),
+    );
+  }
+  return cells;
+}
+/* eslint-enable no-undef */
+const runtime = `\
+${cell}
+${makeCells}`;
+
+// ^^^ runtime to inline in the bundle ^^^
+
 /**
  * @param {ReadFn} read
  * @param {string} moduleLocation
@@ -251,29 +294,17 @@ export const makeBundle = async (read, moduleLocation, options) => {
 ${''.concat(...modules.map(m => m.bundlerKit.getFunctor()))}\
 ]; // functors end
 
-  const cell = (name, value = undefined) => {
-    const observers = [];
-    return Object.freeze({
-      get: Object.freeze(() => {
-        return value;
-      }),
-      set: Object.freeze((newValue) => {
-        value = newValue;
-        for (const observe of observers) {
-          observe(value);
-        }
-      }),
-      observe: Object.freeze((observe) => {
-        observers.push(observe);
-        observe(value);
-      }),
-      enumerable: true,
-    });
-  };
-
-  const cells = [
-${''.concat(...modules.map(m => m.bundlerKit.getCells()))}\
-  ];
+//runtime
+  ${''.concat(
+    runtime,
+    ...Array.from(parsersInUse).map(parser => getRuntime(parser)),
+  )}
+// runtime end
+  const cells = makeCells(
+${JSON.stringify([...modules.map(m => m.bundlerKit.getCells())], null, 2)},
+/* export * from */
+${JSON.stringify(modules.flatMap(m => m.bundlerKit.reexportedCells || []))}
+);
 
 ${''.concat(...modules.map(m => m.bundlerKit.getReexportsWiring()))}\
 
@@ -283,8 +314,6 @@ ${''.concat(...modules.map(m => m.bundlerKit.getReexportsWiring()))}\
     cells[index]['*'] = cell('*', namespaces[index]);
   }
 
-${''.concat(...Array.from(parsersInUse).map(parser => getRuntime(parser)))}
-
 ${''.concat(...modules.map(m => m.bundlerKit.getFunctorCall()))}\
 
   return cells[cells.length - 1]['*'].get();

packages/compartment-mapper/test/snapshots/test-bundle.js.md

@@ -0,0 +1,103 @@
+import test from 'ava';
+
+import parserJson from '../src/parse-json.js';
+// import parserText from '../src/parse-text.js';
+// import parserBytes from '../src/parse-bytes.js';
+import parserArchiveCjs from '../src/parse-archive-cjs.js';
+import parserArchiveMjs from '../src/parse-archive-mjs.js';
+
+import mjsSupport from '../src/bundle-mjs.js';
+import cjsSupport from '../src/bundle-cjs.js';
+import jsonSupport from '../src/bundle-json.js';
+
+const textEncoder = new TextEncoder();
+
+const tests = [
+  {
+    name: 'pre-mjs-json',
+    parser: parserArchiveMjs,
+    bundlerKit: mjsSupport,
+    assertions: (t, kit) => {
+      t.deepEqual(kit.getCells(), ['default', 'a', 'x']);
+      t.deepEqual(kit.reexportedCells, [
+        ['<index for self>', '<index for: ./b>'],
+      ]);
+      t.is(
+        kit.getReexportsWiring().trim(),
+        'Object.defineProperties(cells[<index for self>], {"z": { value: cells[<index for: x>]["x"] } });',
+      );
+    },
+    sample: `
+      import rea from './a';
+      export * from './b';
+      export { x as z } from 'x';
+      export const a = 1;
+      export default a;
+      import.meta.uttered
+    `,
+  },
+  {
+    name: 'pre-cjs-json',
+    parser: parserArchiveCjs,
+    bundlerKit: cjsSupport,
+    assertions: (t, kit) => {
+      t.deepEqual(kit.getCells(), ['a', 'b', 'default']);
+      t.is(kit.reexportedCells, undefined);
+    },
+    sample: `
+      const a = require('a');
+      const b = 1
+      module.exports = { a, b };
+    `,
+  },
+  {
+    name: 'json',
+    parser: parserJson,
+    bundlerKit: jsonSupport,
+    assertions: (t, kit) => {
+      t.deepEqual(kit.getCells(), ['default']);
+      t.is(kit.reexportedCells, undefined);
+    },
+    sample: `
+      { "name": "foo" }
+    `,
+  },
+];
+
+tests.forEach(({ name, parser, bundlerKit, sample, assertions }) => {
+  test(`bundler kit / ${name}`, async t => {
+    const module = await parser.parse(
+      textEncoder.encode(sample),
+      '_specifier',
+      '_location',
+      '_packageLocation',
+    );
+
+    const { imports = [], reexports = [] } = module.record;
+    const kit = bundlerKit.getBundlerKit({
+      index: '<index for self>',
+      indexedImports: Object.fromEntries(
+        [...imports, ...reexports].map(importSpecifier => [
+          importSpecifier,
+          `<index for: ${importSpecifier}>`,
+        ]),
+      ),
+      record: module.record,
+    });
+
+    assertions(t, kit);
+
+    // all kits need to pass these:
+    t.is(typeof bundlerKit.runtime, 'string');
+
+    t.is(typeof kit.getFunctor, 'function');
+    t.is(typeof kit.getCells, 'function');
+    t.is(typeof kit.getReexportsWiring, 'function');
+    t.is(typeof kit.getFunctorCall, 'function');
+
+    t.is(typeof kit.getFunctor(), 'string');
+    t.true(Array.isArray(kit.getCells()));
+    t.is(typeof kit.getReexportsWiring(), 'string');
+    t.is(typeof kit.getFunctorCall(), 'string');
+  });
+});